线程间同步通信——生产者消费者模型

本文链接：https://blog.csdn.net/qq_58158950/article/details/136105599

本文介绍了如何使用C++中的互斥锁、条件变量和队列实现生产者-消费者模型，通过`unique_lock`管理线程同步，确保了生产者和消费者线程之间的协作和同步操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

#include<iostream>
#include<thread>
#include<mutex>
#include<condition_variable>
#include<queue>
using namespace std;

class Queue{
public:
    void put(int val)
    {
        unique_lock<mutex> lock(_queMtx);
        while(!_que.empty())
        {
            //队列不为空，应当阻塞生产线程，通知消费线程去消费
            /*
            #1 生产者线程进入等待状态
            #2 把_queMtx互斥锁解开，
               此处必须使用unique_lock，不能使用lock_guard,因为lock_guard不能作为参数进行传递
            */
            cv.wait(lock);
        }

        //队列为空，生产
        _que.push(val);
        //生产者生产完毕，通知所有消费者进行消费
        cv.notify_all();
        cout<<"生产者 生产"<<val<<"号物品！"<<endl;

    }

    void get()
    {
        unique_lock<mutex> lock(_queMtx);
        while(_que.empty())
        {
            //队列为空。消费者阻塞当前线程，并通知生产者生产
            /*
            #1 消费者线程进入等待状态
            #2 把_queMtx互斥锁解开，
               此处必须使用unique_lock，不能使用lock_guard,因为lock_guard不能作为参数进行传递
            */
            cv.wait(lock);
        }
        //队列不为空，进行消费
        int val=_que.front();
        _que.pop();
        //消费完毕，通知生产者进行生产
        cv.notify_all();
        cout<<"消费者 消费"<<val<<"号物品"<<endl;
    }
private:
    queue<int> _que;
    mutex _queMtx;
    condition_variable cv;
};

void produce(Queue* que)
{
    for(int i=0;i<10;i++)
    {
        que->put(i);
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
}

void consumer(Queue* que)
{
    for(int i=0;i<10;i++)
    {
        que->get();
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
}

int main()
{
    Queue que;
    thread t1(produce,&que);
    thread t2(consumer,&que);

    t1.join();
    t2.join();
}