从生产者-消费者模型中学习互斥量，锁，条件变量

本文链接：https://blog.csdn.net/qq_43964318/article/details/130870632

经典的并发控制模型

主要是练习mutex unique_lock conditional_variable
[[20 原子操作]]

一、互斥量

1 mutex 互斥量

mutex 是一种互斥的同步原语，用于保护共享资源的访问，确保在同一时间只有一个线程可以访问共享资源。通过对互斥量加锁和解锁，可以实现对共享资源的独占访问。

2 shared_mutex 共享互斥量

允许多个线程同时获取共享访问权限，适用于读多写少的场景。要想实现共享的概念，可以使用与shared_lock 包装器搭配使用[[10 生产者-消费者模型(互斥量，锁，条件变量)#4 shared_lock]]。

二、互斥量包装器

1 lock_guard

轻量级的互斥量包装器，用于自动获取互斥锁并在作用域结束时自动释放锁。它适用于临界区的简单互斥保护，没有额外的灵活性

2 unique_lock 独占锁

unique_lock 是一个灵活的互斥量包装器，提供了更高级别的互斥操作。它是基于互斥量的封装，可以通过构造函数或成员函数的方式对互斥量进行加锁和解锁。与普通的 lock() 和 unlock() 不同，unique_lock 在创建时可以选择性地对互斥量进行加锁，也可以在任何时候手动加锁或解锁。
mtx.lock() 和 mtx.unlock();

自动加锁和解锁
延迟加解锁，允许在需要时手动加锁和解锁，如加锁、解锁、尝试加锁等：lock.lock();, lock.unlock();, lock.try_lock();
可移动性， std::unique_lock 对象可以被移动，因此可以在不同线程之间传递所有权。这对于实现资源所有权的转移非常有用。

3 scoped_lock

C++17引入的互斥量包装器，可以同时锁定任意数量的互斥量，还可以避免死锁，因为它使用了无死锁的算法来获取多个互斥量。它会按照参数的顺序来进行加锁，并确保在作用域结束时以相反的顺序释放锁。
不支持手动的加锁和解锁操作。

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

std::mutex mtx1;
std::mutex mtx2;

void Worker()
{
    // 同时锁定mtx1和mtx2
    std::scoped_lock lock(mtx1, mtx2);

    // 执行任务
    std::cout << "Worker: Doing some work..." << std::endl;
}

int main()
{
    std::thread workerThread(Worker);

    // 等待工作线程完成
    workerThread.join();

    return 0;
}

4 shared_lock

共享锁的互斥量包装器，用于实现共享所有权的线程同步。它允许多个线程同时共享对互斥资源的访问，提高了并发性能。

#include <iostream>
#include <thread>
#include <shared_mutex>

std::shared_mutex mtx;
int sharedData = 0;

void Reader()
{
    std::shared_lock lock(mtx);  // 获取共享锁

    // 读取共享数据
    std::cout << "Reader: Shared data = " << sharedData << std::endl;
}

void Writer()
{
    std::unique_lock lock(mtx);  // 获取独占锁

    // 修改共享数据
    sharedData += 1;
    std::cout << "Writer: Incremented shared data" << std::endl;
}

int main()
{
    std::thread readerThread1(Reader);
    std::thread readerThread2(Reader);
    std::thread writerThread(Writer);

    readerThread1.join();
    readerThread2.join();
    writerThread.join();

    return 0;
}

三、条件变量

条件变量（Condition Variable）是一种线程同步的机制，用于线程间的等待和通知。条件变量允许一个或多个线程在满足特定条件之前进行等待，一旦条件满足，其他线程可以通知等待的线程继续执行。

1、使用步骤

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

std::mutex mtx;
std::condition_variable cv;
std::string flag("A");

void PrintA()
{
    while(true) {
        std::unique_lock<std::mutex> lck(mtx);
        while (flag == "B") {
            cv.wait(lck);
        }
        std::this_thread::sleep_for(std::chrono::seconds(1));
        std::cout << "A" << std::endl;
        flag = "B";
        cv.notify_all();
    }
}

void PrintB()
{
    while(true) {
        std::unique_lock<std::mutex> lck(mtx);
        while (flag == "A") {
            cv.wait(lck);     // cv.wait(lck, lambda)
        }
        std::this_thread::sleep_for(std::chrono::seconds(1));
        std::cout << "B" << std::endl;
        flag = "A";
        cv.notify_all();
    }
}

int main()
{
    std::thread t1(PrintA);
    std::thread t2(PrintB);
    t1.join();
    t2.join();
    std::cin.get();
}