C++多线程实现

互斥锁

std::unique_lock：接管mutex互斥锁，离开作用域时自动解锁

std::condition_variable：使用它的wait和notify_all函数。

wait：TRUE：直接往下执行。

false：

1. 释放锁，允许其他位置上锁，并陷入阻塞状态。

2. 等待其他位置执行notify_all唤醒该线程。

3. 唤醒后，立刻上锁，往下执行。

#include <condition_variable>
#include <mutex>
#include <deque>

// FIXME: double check
template <typename T> class channel
{
  public:
    channel(int buffer_size) :buffer_size(buffer_size) {}

    T get()
    {
        // std::lock_guard<std::mutex> _(mu);
        std::unique_lock<std::mutex> lk(mu);    // 上锁,使得put阻塞
        /*  参数为false:此时buffer中没有数据,需要等待直到buffer有数据再向下进行.
                1. 释放锁mu
                2. 等待其他其他线程调用notify_one或notify_all
                3. 一旦调用就唤醒了当前线程,重新对mu上锁,往下执行
            参数为true:不做任何操作等待,直接往下进行
            功能:确保了在buffer有数据时读取数据,无数据时等待buffer压入数据后再读取数据*/
        cv.wait(lk, [&]() { return buffer.size() > 0; });

        const T x = buffer.front();
        buffer.pop_front();

        // lk.unlock();
        cv.notify_all();

        return x;
    }

    void put(T x)
    {
        // std::lock_guard<std::mutex> _(mu);
        std::unique_lock<std::mutex> lk(mu);
//        cv.wait(lk, [&]() { return buffer.size() < buffer_size; });//为了读取视频
//        std::cout<<buffer_size<<std::endl;
        if(buffer.size()<buffer_size)
            buffer.push_back(x);
        else
        {

            buffer.clear();
            buffer.push_back(x);
        }

        // lk.unlock();
        cv.notify_all();
    }

  private:
    std::mutex mu;//互斥锁（英语：英语：Mutual exclusion，缩写 Mutex）是一种用于多线程编程中，防止两条线程同时对同一公共资源（比如全局变量）进行读写的机制。
    std::deque<T> buffer;
    const int buffer_size;
    std::condition_variable cv;//当 std::condition_variable 对象的某个 wait 函数被调用的时候，
    //它使用 std::unique_lock(通过 std::mutex) 来锁住当前线程。当前线程会一直被阻塞，直到另外一个线程在相同的 std::condition_variable 对象上调用了 notification 函数来唤醒当前线程。
};