通常我们使用锁保护线程间共享数据，这也是最基本的方式。

当访问共享数据前，使用互斥量将相关数据锁住，再当访问结束后，再将数据解锁。线程库需要保证，当一个线程使用特定互斥量锁住共享数据时，其他的线程想要访问锁住的数据，都必须等到之前那个线程对数据进行解锁后，才能进行访问。这就保证了所有线程能看到共享数据，而不破坏不变量。

1 使用互斥量

C++提供 std::mutex创建互斥量，通过调用 lock()上锁，unlock()解锁。

为方便使用，C++提供RAII语法的模板类 std::lock_guard()，可以在离开锁作用域是自动解锁。其有以下特点：

• 创建即加锁，作用域结束自动析构并解锁，无需手动解锁
• 不能中途解锁
• 不能复制

show me the case

int g_i = 0;
std::mutex g_i_mutex;

void safe_increment() {
    std::lock_guard lock(g_i_mutex); //safe_increment结束时自动解锁
    g_i++;
}

2 其他类型互斥量

接下来介绍另外两种互斥量： std::recursive_mutex和 shared_mutex

2.1 recursive_mutex

recursive_mutex和 mutex行为几乎一致，区别在于提供排他性递归所有权语义，已经获得一个递归互斥体的所有权的线程允许在同一个互斥体上再次调用 lock()和 try_lock(), 调用线程调用 unlock的次数应该等于获的这个递归互斥锁的次数，在匹配次数时解锁。

比如函数A需要获取锁mutex，函数B也需要获取锁mutex，同时函数A中还会调用函数B。如果使用 std::mutex必然会造成死锁。但是使用 std::recursive_mutex就可以解决这个问题

2.2 shared_mutex(C++ 17)

shared_mutex 类是一个同步原语，可用于保护共享数据不被多个线程同时访问。与便于独占访问的其他互斥类型不同，shared_mutex 拥有二个访问级别：

• 共享 - 多个线程能共享同一互斥的所有权。
• 独占性 - 仅一个线程能占有互斥。

若一个线程已获取独占性锁（通过 lock 、 try_lock ），则无其他线程能获取该锁（包括共享的）。仅当任何线程均未获取独占性锁时，共享锁能被多个线程获取（通过 lock_shared 、 try_lock_shared ）。在一个线程内，同一时刻只能获取一个锁（共享或独占性）。共享互斥体在能由任何数量的线程同时读共享数据，但一个线程只能在无其他线程同时读写时写同一数据时特别有用。

• 排他性锁定
  • lock(): 锁定互斥，若互斥则阻塞
  • try_lock(): 尝试锁定互斥，若互斥不可用则返回
  • unlock(): 解锁互斥
• 共享锁定
  • lock_shared():为共享所有权锁定互斥，若互斥不可用则阻塞
  • try_lock_shared(): 尝试为共享所有权锁定互斥，若互斥不可用则返回
  • unlock_shard(): 解锁互斥

3 各种锁介绍

前面已经简单介绍了 std::lock_guard，接下来将介绍其他类型的常用锁。

3.1 std::unique_lock -- 更加灵活的锁

std::unique_lock比 std::lock_guard灵活很多，效率上差一点，内存占用多一点，可移动，但不可复制。

std::unique_lock构造时除了接受第一个参数mlock, 可接受第二个参数，指定锁定策略：

• defer_lock_t：不获得互斥的所有权，即仅仅构造unique_lock与mlock关联，但是并不上锁
• try_to_lock_t：尝试获得互斥的所有权而不阻塞，可以使用成员函数 bool owns_lock()检测是否上锁成功
• adopt_lock_t：假设调用方线程已拥有互斥的所有权，即构造构造unique_lock与mlock关联之前，已经对mlock加锁

show me the case

//defer_lock_t
void transfer(bank_account &from, bank_account &to, int amount)
{
    // 锁定两个互斥而不死锁
    std::lock(from.m, to.m); //对from.m和to.m加锁
    // 保证二个已锁定互斥在作用域结尾解锁
    std::lock_guard<std::mutex> lock1(from.m, std::adopt_lock);
    std::lock_guard<std::mutex> lock2(to.m, std::adopt_lock);
 
    from.balance -= amount;
    to.balance += amount;
}
//try_to_lock_t
for (int i = 1; i <= 5000; i++) {
    std::unique_lock<std::mutex> munique(mlock, std::try_to_lock);
    if (munique.owns_lock() == true) { //加锁成功
        s += i;
    }
    else {
        // 执行一些没有共享内存的代码
    }

//adopt_lock_t
void transfer(bank_account &from, bank_account &to, int amount)
{
    // 保证二个已锁定互斥在作用域结尾解锁
    std::unique_lock<std::mutex> lock1(from.m, std::defer_lock);
    std::unique_lock<std::mutex> lock2(to.m, std::defer_lock);
    std::lock(lock1, lock2);  //对互斥量加锁
 
    from.balance -= amount;
    to.balance += amount;
}

不同域中互斥量所有权的传递
std::unique_lock实例没有与自身相关的互斥量，一个互斥量的所有权可以通过移动操作，在不同的实例中进行传递。某些情况下，这种转移是自动发生的，例如:当函数返回一个实例；另些情况下，需要显式的调用 std::move()来执行移动操作。

std::unique_lock<std::mutex> get_lock()
{
  extern std::mutex some_mutex;
  std::unique_lock<std::mutex> lk(some_mutex); //构造unique_lock
  prepare_data();
  return lk;  //返回unique_lock的指针，离开作用域lk不会被销毁，而是move到域外
}
void process_data()
{
  std::unique_lock<std::mutex> lk(get_lock());  // 获得锁所有权
  do_something();
}

3.2 单次调用加锁

std::once_flag是 std::call_once的辅助类。传递给多个 std::call_once 调用的 std::once_flag 对象允许那些调用彼此协调，从而只令调用之一实际运行完成。

std::call_once准确执行一次可调用 (Callable) 对象 f ，即使同时从多个线程调用。

• 若在调用 call_once 的时刻， flag 指示已经调用了 f ，则 call_once 立即返回（称这种对 call_once 的调用为消极）
• 否则调用可调用 (Callable) 对象f执行
  • 若该调用抛异常，则传播异常给 call_once 的调用方，并且不翻转 flag ，以令其他调用将得到尝试（称这种对 call_once 的调用为异常）。
  • 若该调用正常返回（称这种对 call_once 的调用为返回），则翻转 flag ，并保证以同一 flag 对 call_once 的其他调用为消极。

std::once_flag flag1, flag2;
 
void simple_do_once()
{
    std::call_once(flag1, [](){ std::cout << "Simple example: called once\n"; });
}
 
void may_throw_function(bool do_throw)
{
  if (do_throw) {
    // 这会出现多于一次, 因为出现异常的话，其他的调用会得到尝试
    std::cout << "throw: call_once will retry\n"; 
    throw std::exception();
  }
  // 如果未发生异常，则保证函数只会被调用一次
  std::cout << "Didn't throw, call_once will not attempt again\n"; 
}
 
void do_once(bool do_throw)
{
  try {
    std::call_once(flag2, may_throw_function, do_throw);
  }
  catch (...) {
  }
}
 
int main()
{
    std::thread st1(simple_do_once);  // 1
    std::thread st2(simple_do_once);  // 2
    std::thread st3(simple_do_once);  // 3
    std::thread st4(simple_do_once);  // 4
    st1.join();
    st2.join();
    st3.join();
    st4.join();
 
    std::thread t1(do_once, true);  //5
    std::thread t2(do_once, true);  //6
    std::thread t3(do_once, false); //7
    std::thread t4(do_once, true);  //8
    t1.join();
    t2.join();
    t3.join();
    t4.join();
}

可能的结果：
Simple example: 
//1、2、3、4只会成功调用一次
called once  
//5、6、8会触发异常，现在的结果可能是5、6触发两次异常，7调用成功，8不会再触发调用而是立刻返回
throw: call_once will retry  
throw: call_once will retry
Didn't throw, call_once will not attempt again

3.3 同时加锁多个互斥量

3.3.1 std::lock

锁定给定的可锁定 (Lockable) 对象 lock1 、 lock2 、 ... 、 lockn ，用免死锁算法避免死锁。以对 lock 、 try_lock 和 unlock 的未指定系列调用锁定对象。若调用 lock 或 unlock 导致异常，则在重抛前对任何已锁的对象调用 unlock。

std::lock锁住的锁不会自动释放锁，需要手动解锁， 因此 std::lock常与 std::lock_guard或者 std::unique_lock结合使用，比如

std::lock(m1, m2); //此处加锁，构造的lock_guard无需上锁，离开作用域自动解锁
std::lock_guard lock1(m1, std::adopt_lock);
std::lock_guard lock2(m2, std::adopt_lock); 

或者
std::unique_lock lock1(m1, std::defer_lock);
std::unique_lock lock2(m2, std::defer_lock);
std::lock(lock1, lock2) //构造的unique_lock未上锁，此处加锁，离开作用域自动解锁

std::try_lock的作用是与 std::lock相似，可以同时对多个互斥量加锁而不会死锁，通过以从头开始的顺序调用 try_lock 。

若调用 try_lock 失败，则不再进一步调用 try_lock ，并对任何已锁对象调用 unlock ，返回锁定失败对象的 0 底下标。成功时为 -1 ，否则为锁定失败对象的 0 底下标值。

若调用 try_lock 抛出异常，则在重抛前对任何已锁对象调用 unlock 。

3.3.2 std::scoped_lock(C++ 17)

类 scoped_lock 是提供便利 RAII 风格机制的互斥包装器，它在作用域块的存在期间占有一或多个互斥。

创建 scoped_lock 对象时，它试图取得给定互斥的所有权。控制离开创建 scoped_lock 对象的作用域时，析构 scoped_lock 并释放互斥。若给出数个互斥，则使用免死锁算法，如同以 std::lock 。
show me the case

std::scoped_lock lock(m1, m2);

//等价代码1
std::lock(m1, m2);
std::lock_guard<std::mutex> lk1(m1, std::adopt_lock);
std::lock_guard<std::mutex> lk2(m2, std::adopt_lock);

//等价代码2
std::unique_lock<std::mutex> lk1(m1, std::defer_lock);
std::unique_lock<std::mutex> lk2(m2, std::defer_lock);
std::lock(lk1, lk2);

3.4 共享锁(C++ 14)

std::shared_lock会以共享模式锁定关联的共享互斥（std::unique_lock 可用于以排他性模式锁定）。

class SaferCounter {
    std::shared_mutex mutex;
    unsigned int get() const {
         std::shared_lock<std::shared_mutex> lock(mutex);//获取共享锁，内部执行mutex.lock_shared()
         return value_;  //lock 析构, 执行mutex.unlock_shared();
    }  

    unsigned int increment() {
        std::unique_lock<std::shared_mutex> lock(mutex) //获取独占锁，内部执行mutex.lock()
        value++;
        return value;    //lock 析构, 执行mutex.unlock();
    }
}