1， 条件变量-生产消费者模型

#include <iostream>
#include <string>
#include <thread>                      // 线程类头文件。
#include <mutex>                      // 互斥锁类的头文件。
#include <deque>                      // deque容器的头文件。
#include <queue>                      // queue容器的头文件。
#include <condition_variable>  // 条件变量的头文件。
using namespace std;
class AA
{
    mutex m_mutex;                      // 互斥锁。
    condition_variable m_cond;          // 条件变量。
    queue<string, deque<string>> m_q;   // 缓存队列，底层容器用deque。
public:
    void incache(int num)     // 生产数据，num指定数据的个数。
    {
        lock_guard<mutex> lock(m_mutex);   // 申请加锁。
        for (int ii=0 ; ii<num ; ii++)
        {
            static int bh = 1;           // 超女编号。
            string message = to_string(bh++) + "号超女";    // 拼接出一个数据。
            m_q.push(message);     // 把生产出来的数据入队。
        }
        //m_cond.notify_one();     // 唤醒一个被当前条件变量阻塞的线程。
        m_cond.notify_all();          // 唤醒全部被当前条件变量阻塞的线程。
    }

    void outcache()   {    // 消费者线程任务函数。
        while (true)   {
            // 把互斥锁转换成unique_lock<mutex>，并申请加锁。
            unique_lock<mutex> lock(m_mutex);

            // 条件变量虚假唤醒：消费者线程被唤醒后，缓存队列中没有数据。
            //while (m_q.empty())    // 如果队列空，进入循环，否则直接处理数据。必须用循环，不能用if
            //    m_cond.wait(lock);  // 1）把互斥锁解开；2）阻塞，等待被唤醒；3）给互斥锁加锁。
            m_cond.wait(lock, [this] { return !m_q.empty(); });

            // 数据元素出队。
            string message = m_q.front();  m_q.pop();
            cout << "线程：" << this_thread::get_id() << "，" << message << endl;
            lock.unlock();      // 手工解锁。

            // 处理出队的数据（把数据消费掉）。
            this_thread::sleep_for(chrono::milliseconds(100));   // 假设处理数据需要100毫秒。
        }
    }
};

int main()
{
    AA aa;

    thread t1(&AA::outcache, &aa);     // 创建消费者线程t1。
    thread t2(&AA::outcache, &aa);     // 创建消费者线程t2。
    thread t3(&AA::outcache, &aa);     // 创建消费者线程t3。

    this_thread::sleep_for(chrono::seconds(2));    // 休眠2秒。
    aa.incache(2);      // 生产2个数据。

    this_thread::sleep_for(chrono::seconds(3));    // 休眠3秒。
    aa.incache(5);      // 生产5个数据。

    t1.join();   // 回收子线程的资源。
    t2.join();
    t3.join();
    return 0;
}

2, 原子类型atomic

#include <iostream>
#include <atomic>     // 原子类型的头文件。
using namespace std;

int main()
{
    atomic<int> a = 3;       // atomic(T val) noexcept;  // 转换函数。
    cout << "a=" << a.load() << endl;   // 读取原子变量a的值。输出：a=3
    a.store(8);      // 把8存储到原子变量中。
    cout << "a=" << a.load() << endl;   // 读取原子变量a的值。 输出：a=8

    int old;        // 用于存放原值。
    old = a.fetch_add(5);         // 把原子变量a的值与5相加，返回原值。
    cout << "old = " << old <<"，a = " << a.load() << endl;   // 输出：old=8，a=13
    old = a.fetch_sub(2);         // 把原子变量a的值减2，返回原值。
    cout << "old = " << old << "，a = " << a.load() << endl;   // 输出：old=13，a=11

    atomic<int> ii = 3;  // 原子变量
    int expect = 4;         // 期待值
    int val = 5;               // 打算存入原子变量的值
    // 比较原子变量的值和预期值expect，
    // 如果当两个值相等，把val存储到原子变量中；
    // 如果当两个值不相等，用原子变量的值更新预期值。
    // 执行存储操作时返回true，否则返回false。
    bool bret = ii.compare_exchange_strong(expect, val);
    cout << "bret=" << bret << endl;
    cout << "ii=" << ii << endl;
    cout << "expect=" << expect << endl;
}