互斥锁和条件变量实现生成者消费者队列

介绍几个概念

1. 互斥量 mutex
   mutex是一个类，创建一个mutex mtx对象，在需要加锁的代码前后加上mtx.lock()和mtx.unlock(),实现互斥锁的加锁和解锁。但是在加锁和解锁的代码中间可能会出现异常，导致没有进行解锁。
   为了解决这个问题引入了两种锁类型（将加锁和解锁作为一个原子性的操作，同智能指针类似，超过使用范围自动解锁）：
   1. lock_guard，与Mutex RAII相关， 方便对互斥量上锁
   2. unique_lock, 与Mutex RAII相关， 方便对互斥量上锁，同时提供了更好的上锁和解锁控制。

以下work1、work2、work3都是对mutex加锁、解锁。

#include <iostream>
#include <memory>
#include <mutex>
#include <thread>

using namespace std;

mutex mtx;
int k = 0;

void work1(){
    for(int i=0; i<10000; ++i){
        lock_guard<mutex> lg(mtx);
        ++k;		// ++k出现异常时，mtx也会自动释放锁。
    }
}
void work2(){
    for(int i=0; i<10000; ++i){
        unique_lock<mutex> lck(mtx);
        ++k;		// ++k出现异常时，mtx也会自动释放锁。
    }
}

void work3(){
    for(int i=0; i<10000; ++i){
        mtx.lock();
        ++k;		// ++k出现异常时，下一步的unlock不会执行。
        mtx.unlock();
    }
}


int main(){
    thread t1(work1);
    thread t2(work2);
    thread t3(work3);
    t1.join();
    t2.join();
    t3.join();
    cout<<"sum:"<<k<<endl;
}

2. 条件变量 condition_variable
   条件变量常与unique_lock<mutex>联合使用，当满足条件时通过条件变量对象（假设为cv）来cv.wait()来阻塞当前线程，同时对互斥量解锁。直到另外一个线程在相同的 std::condition_variable 对象上调用了 notification 函数来唤醒当前线程，然后当前进程对mutex互斥量在加锁。

以下实现生成者消费者队列模型

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

queue<int> q;
mutex mtx; // 全局的锁,互斥线程访问队列
condition_variable cv; // 定义全局的条件变量，同步线程
int maxSize = 20;

void consumer(){
    while(true){
        this_thread::sleep_for(chrono::milliseconds(2000));
        unique_lock<mutex> lck(mtx);
        while(q.empty())
            cv.wait(lck);
            
        q.pop();
        cout << "consumer:" << this_thread::get_id() << ": "<<q.size()<<endl;
        cv.notify_all();
        // lck.unlock();
    }
}

void producer(int id){
    while(true){
        this_thread::sleep_for(chrono::milliseconds(1000));

        unique_lock<mutex> lck(mtx);
        while(q.size()==maxSize)
            cv.wait(lck);
        
        q.push(id);
        cout << "producer:" << this_thread::get_id() << ": "<<q.size()<<endl;
        cv.notify_all();
        // lck.unlock();
    }
}


int main(){
    thread consumers[2], producers[2];

    for(int i=0; i<2; ++i){
        consumers[i] = thread(consumer);
        producers[i] = thread(producer, i+1);
    }

    for(int i=0; i<2; ++i){
        producers[i].join();
        consumers[i].join();
    }
    return 0;
}