生产者-消费者问题

1. 条件变量实现

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

// 定义缓冲区大小  
const int kMaxBufferSize = 5;  
 
// 定义一个互斥锁  
std::mutex mtx;  
// 定义一个条件变量  
std::condition_variable condVar;  
// 定义一个队列作为缓冲区  
std::queue<int> buffer;  
  
// 生产者函数  
void producer(int id) {  
    for (int i = 0; i < 10; ++i) {  
        std::unique_lock<std::mutex> lock(mtx);  
        // 等待缓冲区不满  
        condVar.wait(lock, [] { return buffer.size() < kMaxBufferSize; });  
        // 生产数据  
        int item = i + id * 10;  
        buffer.push(item);  
        std::cout << "Producer " << id << " produced " << item << std::endl;  
        // 通知消费者缓冲区有数据了  
        condVar.notify_one();  
    }  
}  
  
// 消费者函数  
void consumer(int id) {  
    for (int i = 0; i < 10; ++i) {  
        std::unique_lock<std::mutex> lock(mtx);  
        // 等待缓冲区有数据  
        condVar.wait(lock, [] { return !buffer.empty(); });  
        // 消费数据  
        int item = buffer.front();  
        buffer.pop();  
        std::cout << "Consumer " << id << " consumed " << item << std::endl;  
        // 通知生产者缓冲区有空位了  
        condVar.notify_one();  
    }  
}  
  
int main() {  
    // 创建生产者和消费者线程  
    std::thread producer1(producer, 1);  
    std::thread producer2(producer, 2);  
    std::thread consumer1(consumer, 1);  
    std::thread consumer2(consumer, 2);  
  
    // 等待所有线程完成  
    producer1.join();  
    producer2.join();  
    consumer1.join();  
    consumer2.join();  
  
    return 0;  
}

2. 信号量实现
   互斥锁和信号量可以完全替代信号量，实际项目中不用