c++ 生产者消费者队列

c生产者消费者队列是一种解决多线程编程中生产者和消费者之间协作的制。它通过一个共享的队列来实现生产者将数据放入队列，消费者从队列中取出数据的操作。在c语言中，可以使用信号量或互斥锁等机制来实现生产者消费者队列。

在给出的引用中，通过使用一个无界队列(UnBoundedQueue)来实现c生产者消费者队列。生产者线程通过调用Put函数将数据放入队列，消费者线程通过调用Get函数从队列中取出数据进行消费。

相关问题

C++实现生产者消费者问题

生产者消费者问题是一个经典的多线程同步问题，可以使用C++中的互斥锁和条件变量来实现。

以下是一个简单的生产者消费者问题的C++代码示例：

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

using namespace std;

queue<int> q; // 生产者消费者队列
mutex m; // 互斥锁
condition_variable cv; // 条件变量
const int MAX_SIZE = 10; // 队列最大容量
int product_id = 0; // 生产者生产的产品编号

// 生产者线程函数
void producer() {
    while (true) {
        unique_lock<mutex> lock(m);
        // 如果队列已满，则等待
        cv.wait(lock, []() { return q.size() < MAX_SIZE; });
        // 生产产品
        q.push(++product_id);
        cout << "Producer produces product " << product_id << endl;
        // 通知消费者队列中有产品可用
        cv.notify_all();
        lock.unlock();
        // 生产完一个产品后休眠
        this_thread::sleep_for(chrono::milliseconds(500));
    }
}

// 消费者线程函数
void consumer() {
    while (true) {
        unique_lock<mutex> lock(m);
        // 如果队列为空，则等待
        cv.wait(lock, []() { return !q.empty(); });
        // 消费产品
        int product = q.front();
        q.pop();
        cout << "Consumer consumes product " << product << endl;
        // 通知生产者队列中有空位
        cv.notify_all();
        lock.unlock();
        // 消费完一个产品后休眠
        this_thread::sleep_for(chrono::milliseconds(1000));
    }
}

int main() {
    thread producer_thread(producer);
    thread consumer_thread(consumer);
    producer_thread.join();
    consumer_thread.join();
    return 0;
}

在上面的代码中，我们定义了一个生产者消费者队列 `q`，一个互斥锁 `m` 和一个条件变量 `cv`。生产者线程函数 `producer` 不断地生产产品，并将其加入队列中，如果队列已满，则等待条件变量 `cv`。消费者线程函数 `consumer` 不断地消费产品，并将其从队列中移除，如果队列为空，则等待条件变量 `cv`。

在生产者线程函数中，我们使用了 `unique_lock` 对互斥锁进行加锁，然后调用 `cv.wait` 等待条件变量。在等待期间，该线程会释放互斥锁，等待其他线程调用 `notify_all` 函数通知该线程条件变量的状态发生了变化。当条件变量的状态发生变化时，线程会重新获取互斥锁并继续执行。

在消费者线程函数中，我们也使用了 `unique_lock` 对互斥锁进行加锁，并调用 `cv.wait` 等待条件变量。当队列不为空时，线程从队列中取出一个产品并进行消费，并使用 `cv.notify_all` 函数通知生产者线程队列中有空位。

在主函数中，我们创建了两个线程分别执行生产者线程函数和消费者线程函数，并等待两个线程执行完毕后退出程序。

生产者消费者代码C++

以下是一个简单的C++生产者消费者代码示例：

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

using namespace std;

deque<int> q;
mutex mu;
condition_variable cond;

void producer() {
    int count = 10;
    while (count > 0) {
        unique_lock<mutex> locker(mu);
        q.push_front(count);
        locker.unlock();
        cond.notify_one();
        count--;
    }
}

void consumer() {
    int data = 0;
    while (data != 1) {
        unique_lock<mutex> locker(mu);
        cond.wait(locker, [](){return !q.empty();});
        data = q.back();
        q.pop_back();
        locker.unlock();
        cout << "Consumer got a value from producer: " << data << endl;
    }
}

int main() {
    thread t1(producer);
    thread t2(consumer);
    t1.join();
    t2.join();
    return 0;
}

该示例中，生产者线程不断向队列中添加数据，消费者线程则从队列中取出数据并进行处理。其中，互斥锁和条件变量用于保证线程安全和线程之间的同步。在条件变量的wait函数中，lambda表达式用于判断队列是否为空，如果为空则挂起消费者线程，直到有新的数据被添加到队列中。