在ubuntu中，多个生产者与多个消费者，编写c程序完整代码，假设有一家米粉店，有三个厨师分别生产三种米粉，有多个消费者，有多个碗可以存放产品，三个厨师按需生成米粉放入碗中，消费者依序取用米粉。

在Ubuntu中实现这个场景，我们可以使用互斥锁（mutexes）、条件变量（condition variables）以及队列（queue）等并发工具。这里是一个简化的C++代码示例，假设我们使用`std::queue`、`std::mutex`和`std::condition_variable`：

#include <iostream>
#include <thread>
#include <queue>
#include <mutex>
#include <condition_variable>

enum class Type { Vermicelli1, Vermicelli2, Vermicelli3 };
const int MAX_WORLDS = 10; // 碗的数量

class Chef {
private:
    std::queue<Type> queue_;
    std::mutex mutex_;
    std::condition_variable cond_var_;
public:
    Chef() {}

    void startProducing(Type type) {
        for (int i = 0; i < MAX_WORLDS; i++) {
            std::unique_lock<std::mutex> lock(mutex_);
            while (queue_.empty()) {
                cond_var_.wait(lock);
            }
            // 生产米粉并加入队列
            queue_.push(type);
            lock.unlock();
            std::cout << "Chef " << type << " produced a bowl of " << type << "\n";
        }
        std::cout << "Chef " << type << " stopped producing\n";
    }

    void produce() {
        // 模拟生产过程，这里仅作示例
        std::this_thread::sleep_for(std::chrono::seconds(2));
        std::lock_guard<std::mutex> lock(mutex_);
        queue_.push(static_cast<Type>(rand() % 3 + 1)); // 随机选择一种米粉
        cond_var_.notify_one(); // 唤醒等待的消费者
    }
};

class Consumer {
private:
    std::queue<Type> queue_;
    std::mutex mutex_;
public:
    Consumer() {}

    void startConsuming() {
        std::unique_lock<std::mutex> lock(mutex_);
        while (queue_.empty()) {
            cond_var_.wait(lock);
        }
        lock.unlock();

        // 消费者取出并享用米粉
        Type type = queue_.front();
        std::cout << "Consumer took a bowl of " << type << " from Chef.\n";
        queue_.pop();
    }

    void consume() {
        // 模拟消费过程，这里仅作示例
        std::this_thread::sleep_for(std::chrono::seconds(1));
        std::lock_guard<std::mutex> lock(mutex_);
        if (!queue_.empty()) {
            queue_.pop();
        } else {
            std::cout << "No more bowls available, consumer stopped consuming.\n";
            return;
        }
        cond_var_.notify_all(); // 唤醒其他等待的消费者
    }
};

int main() {
    Chef chefs[3] = {Chef(), Chef(), Chef()};
    Consumer consumers[3]; // 假设每个碗对应一个消费者

    std::vector<std::thread> producers, consumers_threads;
    for (int i = 0; i < 3; ++i) {
        producers.push_back(std::thread(Chef::produce, &chefs[i]));
        consumers_threads.push_back(std::thread(Consumer::consume, &consumers[i]));
    }

    for (auto& producer : producers)
        producer.join();

    for (auto& consumer : consumers_threads)
        consumer.join();

    return 0;
}

注意，这只是一个简化版的示例，并未处理所有可能出现的并发问题，如死锁等。在实际项目中，你可能需要添加错误处理和更复杂的数据结构来确保系统的稳定性和正确性。