C++11一些知识点

1、C++11实现生产者与消费者模型

#include <mutex>
#include <condition_variable>
#include <queue> //C++ STL里面的所有容器都不是线程安全的
#include <iostream>
#include <thread>

using namespace std;

class Queue
{
public:
    void put(int val) // 生产者
    {
        unique_lock<std::mutex> lck(mtx);
        while (!que.empty())
        {
            // que不为空，生产者应该通知消费者去消费
            // 生产者应该进入 #1等待状态 #2并把mtx互斥锁释放掉
            cv.wait(lck);
        }
        que.push(val);
        cv.notify_all(); // 通知其他所有消费者可以进行消费了
        //其他线程的得到通知就会从等待状态 ==> 阻塞状态 ==> 获取互斥锁才能继续执行

        cout << "生产者生产：" << val << "号物品" << endl;
    }

    int get() // 消费者
    {
        unique_lock<std::mutex> lck(mtx);
        while (que.empty())
        {
            // 消费者线程发现que是空的，通知生产者线程生产物品
            // #1 进入等待状态 #2把互斥锁mutex释放掉
            cv.wait(lck);
        }
        int val = que.front();
        que.pop();
        cv.notify_all(); //通知其他所有生产者可以进行生产了
        cout << "消费者消费: " << val << "号物品" << endl;
        return val;
    }

private:
    queue<int> que;
    mutex mtx;             // 定义互斥锁，做线程间的胡吃操作
    condition_variable cv; // 定义条件变量，做线程之间的同步通信操作
};

void producer(Queue *que) // 生产者线程
{
    for (int i = 1; i <= 10; ++i)
    {
        que->put(i);
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

void consumer(Queue *que) // 消费者线程
{
    for (int i = 1; i <= 10; ++i)
    {
        que->get();
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

int main()
{
    Queue que; // 两个线程共享的队列
    thread t1(producer, &que);
    thread t2(consumer, &que);
    t1.join();
    t2.join();
}

2、unique_lock与lock_guard的比较

#include <bits/stdc++.h>
#include <mutex>
#include <condition_variable>

using namespace std;

std::mutex mtx;
std::condition_variable cv;

int main()
{
    /***
     * 唤醒在cv上等待的线程
     * 其他在cv上等待的线程收到通知，从等待状态 ==> 阻塞状态 ==> 获得互斥锁 ==> 线程继续向下执行
     * **/
    // cv.notify_all();

    // 它不仅可以用在简单的临界区代码段的互斥操作中，还能用于函数调用过程中
    unique_lock<std::mutex> lck(mtx);
    cv.wait(lck); // #1使线程进入等待状态 #2 lck.unlock()可以把mutex释放掉

    // 不可以用在函数参数传递或者返回过程中，只能用在简单的临界区代码段的互斥操作中
    lock_guard<std::mutex> guard(mtx);

    // mtx.lock();
    // mtx.unlock();

    return 0;
}

引用自：施磊老师的《C++高级课程》