unique_lock & shared_mutex & condition_var

std::unique_lock

比较灵活，锁可转移，会占用比较多的空间，并且比 std::lock_guard 稍慢一些。

void swap(X& lhs, X& rhs)
{
    if(&lhs==&rhs)
        return;
    std::lock(lhs.m,rhs.m); // 1
    std::lock_guard<std::mutex> lock_a(lhs.m,std::adopt_lock);
    // 2 std::adopt_lock 已上锁的互斥量
    std::lock_guard<std::mutex> lock_b(rhs.m,std::adopt_lock);
    // 3
    swap(lhs.some_detail,rhs.some_detail);
}

void swap(X& lhs, X& rhs)
{
    if(&lhs==&rhs)
        return;
    std::lock_guard<std::mutex> lock_a(lhs.m,std::defer_lock);    // 2
    std::lock_guard<std::mutex> lock_b(rhs.m,std::defer_lock);    // 3
    std::lock(lhs.m,rhs.m); // 1
    swap(lhs.some_detail,rhs.some_detail);
}

void swap(X& lhs, X& rhs)
{
    if(&lhs==&rhs)
        return;
    std::unique_lock<std::mutex> lock_a(lhs.m,std::defer_lock);    // 1
    std::unique_lock<std::mutex> lock_b(rhs.m,std::defer_lock); 
   // 1 std::defer_lock 留下未上锁的互斥量
    std::lock(lock_a,lock_b); // 2 互斥量在这里上锁
    swap(lhs.some_detail,rhs.some_detail);
    // std::unique_lock 实例中的标志，来确定该实例是否拥有特定的互斥量;
    // 这个标志是为了确保unlock()在析构函数中被正确调用。
    // 如果实例拥有互斥量，那么析构函数必须调用unlock()；
    // 但当实例中没有互斥量时，析构函数就不能去调用unlock()。
}

void swap(X& lhs, X& rhs)
{
    if(&lhs==&rhs)
        return;
    std::scoped_lock guard(lhs.m,rhs.m); // 1
    swap(lhs.some_detail,rhs.some_detail);
}

std::shared_mutex 

c++版的读写锁
当任一线程拥有一个共享锁时，某一线程尝试获取一个独占锁时，需要等到其他线程放弃他们的锁；
同样的，当任一线程拥有一个独占锁时，其他线程就无法获得共享锁或独占锁，直到第一个线程放弃其拥有的锁。

适合于读取者远远超过写入者的场景，可以提高并发性能。

写锁：
std::lock_guard<std::shared_mutex> lk(entry_mutex);
std::unique_lock<std::shared_mutex> lk(entry_mutex);
读锁：
std::shared_lock<std::shared_mutex> lk(entry_mutex);

std::condition_var

重复等待一个事件或条件
准备数据的线程：
data_cond.notify_one(); // 3
处理数据的线程：
std::unique_lock<std::mutex> lk(mut); // 4  上锁
data_cond.wait(lk,[]{return !data_queue.empty();}); // 5  下锁，阻塞，<上锁，check，satisfy？返回+持有锁：上锁+继续等待>

wait()会检查lamda条件，
当条件满足时返回。
如果条件不满足，
1. wait()函数将解锁互斥量，并且将这个线程置于阻塞或等待状态。
2. 当准备数据的线程调用notify_one()通知条件变量时，处理数据的线程从睡眠状态中苏醒，重新获取互斥锁，并且再次检查条件是否满足。
3. 在条件满足的情况下，从wait()返回并继续持有锁；当条件不满足时，线程将对互斥量解锁，并且重新开始等待。