C++ Mutex

定义

1. 互斥量可以使用在各种方面，常用在对共享数据的读写上。如果有多线程读写一个数据，那么想要保证线程安全，必须对共享变量的读写上锁

头文件

#include <mutex>

类型

1. std::mutex，最基本的Mutex类
2. std::recursive_mutex，递归Mutex
3. std::time_mutex，限时Mutex
4. std::recursive_timed_mutex，限时递归Mutex类
5. std::shared_timed_mutex，限时读写锁（C++14）
6. std::shared_mutex，读写锁（C++17）

std::mutex

构造函数

mutex() noexcept = default;
~mutex() = default;

mutex(const mutex&) = delete;
mutex& operator=(const mutex&) = delete;

1. std::mutex不允许拷贝构造
2. 销毁互斥，若互斥被线程占有，或在占有mutex时线程被终止，则会产生未定义行为

用法

lock

锁定互斥，线程将锁住该互斥量，立即返回
无返回值

1. 如果该互斥量当前没有被其他线程锁住，则调用线程将该互斥量锁住，直到调用unlock之前，该线程一直拥有该锁。
2. 如果当前互斥量被其他线程锁住，则当前的调用线程被阻塞住，直到其他线程unlock该互斥量。
3. 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)。

PS：阻塞≠死锁，阻塞大概率会通畅，死锁一旦产生，则程序结束

try_lock

尝试锁住互斥量，立即返回
成功=True，反之=False

1. 如果当前互斥量没有被其他线程占有，则该线程锁住互斥量，直到该线程调用unlock释放互斥量
2. 如果当前互斥量被其他线程锁住，则当前调用线程返回false，而并不会被阻塞掉
3. 果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)。

unlock

无返回值
解锁互斥。互斥量必须为当前执行线程所锁定(以及调用lock)，否则行为未定义。

example

#include <iostream>
#include <chrono>  // std::chrono
#include <thread>  // std::thread
#include <mutex>  // std::mutex
 
int g_num = 0;  // 为 g_num_mutex 所保护
std::mutex g_num_mutex;
 
void slow_increment(int id) 
{
    for (int i = 0; i < 3; ++i) {
        g_num_mutex.lock();
        ++g_num;
        std::cout << "th" << id << " => " << g_num << '\n';
        g_num_mutex.unlock();
 
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
}  
 
int main()
{
    std::thread t1(slow_increment, 0);
    std::thread t2(slow_increment, 1);
    t1.join();
    t2.join();
}

输出

th0 => 1
th1 => 2
th0 => 3
th1 => 4
th1 => 5
th0 => 6

std::recursive_mutex

定义

递归式互斥锁，同一个线程可以多次获得锁，而不会死锁

PS：lock和unlock的次数必须相等，其他线程才能获得锁

用法

成员与std::mutex一致

#include <iostream>
#include <thread>
#include <mutex>
 
class X {
    std::recursive_mutex m;
    std::string shared;
  public:
    void fun1() {
      m.lock();
      shared = "fun1";
      std::cout << "in fun1, shared variable is now " << shared << '\n';
      m.unlock();
    }
    void fun2() {
      m.lock();
      shared = "fun2";
      std::cout << "in fun2, shared variable is now " << shared << '\n';
      fun3(); // 递归锁在此处变得有用
      std::cout << "back in fun2, shared variable is " << shared << '\n';
      m.unlock();
    }
    void fun3() {
      m.lock();
      shared = "fun3";
      std::cout << "in fun3, shared variable is now " << shared << '\n';
      m.unlock();
    }
};
 
int main() 
{
    X x;
    std::thread t1(&X::fun1, &x);
    std::thread t2(&X::fun2, &x);
    t1.join();
    t2.join();
}

输出

in fun1, shared variable is now fun1
in fun2, shared variable is now fun2
in fun3, shared variable is now fun3
back in fun2, shared variable is fun3

std::time_mutex

定义

增加了带时限的try_lock

用法

try_lock_for

尝试获得锁，若无法立即得到，则最多阻塞timeout_duration或在此期间获得锁，指的是时间段
成功=True，反之=False

example

#include <iostream>
#include <sstream>
#include <thread>
#include <chrono>
#include <vector>
#include <mutex>

std::timed_mutex mutex;

using namespace std::chrono_literals;

void do_work(int id) {
  std::ostringstream stream;
  for (int i = 0; i < 3; ++i) {
    if (mutex.try_lock_for(100ms)) {
      stream << "success ";
      std::this_thread::sleep_for(100ms);
      mutex.unlock();
    } else {
      stream << "failed ";
    }
    std::this_thread::sleep_for(100ms);
  }

  std::cout << "[" << id << "] " << stream.str() << std::endl;
}

int main() {
  // try_lock_for
  std::vector<std::thread> threads;
  for (int i = 0; i < 4; ++i) {
    threads.emplace_back(do_work, i);
  }

  for (auto& t : threads) {
    t.join();
  }
}

输出

[3] failed success failed 
[0] success failed success 
[2] failed failed failed 
[1] success success success 

try_lock_until

尝试锁互斥。直到到达指定的时间才超时，指的是时间点
成功=True，反之=False

example

#include <iostream>
#include <sstream>
#include <thread>
#include <chrono>
#include <vector>
#include <mutex>

std::timed_mutex mutex;
using namespace std::chrono;

void do_work() {
    mutex.lock();
    std::cout << "thread 1, sleeping..." << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(4));
    mutex.unlock();
}
 
void do_work2() {
    auto now = std::chrono::steady_clock::now();
    if (mutex.try_lock_until(now + 5s)) {
        auto end = steady_clock::now();
        std::cout << "try_lock_until success, ";
        std::cout << "time use: " << duration_cast<milliseconds>(end-now).count() 
            << "ms." << std::endl;
        mutex.unlock();
    } else {
        auto end = steady_clock::now();
        std::cout << "try_lock_until failed, ";
        std::cout << "time use: " << duration_cast<milliseconds>(end-now).count() 
            << "ms." << std::endl;
    }
}

int main() {
  // try_lock_until
  std::thread t1(do_work);
  std::thread t2(do_work2);
  t1.join();
  t2.join();
}

输出

thread 1, sleeping...
try_lock_until success, time use: 4000ms.

std::recursive_timed_mutex

定义

以类似std::recursive_mutex的方式，recursive_timed_mutex提供排他性递归锁，同线程可以重复获得锁。另外，recursive_timed_mutex通过try_lock_for与try_lock_until方法，提供带时限地获得recursive_timed_mutex锁，类似std::time_mutex。

std::shared_mutex

定义

c++ 17 新出的具有独占模式和共享模式的锁。

std::shared_mutex 是读写锁，把对共享资源的访问者划分成读者和写者，读者只对共享资源进行读访问，写者则需要对共享资源进行写操作。

它提供两种访问权限的控制：共享性（shared）和排他性（exclusive）。通过lock/try_lock获取排他性访问权限(仅有一个线程能占有互斥)，通过lock_shared/try_lock_shared获取共享性访问权限(多个线程能共享同一互斥的所有权)。这样的设置对于区分不同线程的读写操作特别有用。

std::shared_mutex通常用于多个读线程能同时访问同一资源而不导致数据竞争，但只有一个写线程能访问的情形。

#include <iostream>
#include <mutex>  // 对于 std::unique_lock
#include <shared_mutex>
#include <thread>
 
class ThreadSafeCounter {
 public:
  ThreadSafeCounter() = default;
 
  // 多个线程/读者能同时读计数器的值。
  unsigned int get() const {
    std::shared_lock<std::shared_mutex> lock(mutex_);
    return value_;
  }
 
  // 只有一个线程/写者能增加/写线程的值。
  void increment() {
    std::unique_lock<std::shared_mutex> lock(mutex_);
    value_++;
  }
  
  // 只有一个线程/写者能重置/写线程的值。
  void reset() {
    std::unique_lock<std::shared_mutex> lock(mutex_);
    value_ = 0;
  }
 
 private:
  mutable std::shared_mutex mutex_;
  unsigned int value_ = 0;
};
 
int main() {
  ThreadSafeCounter counter;
 
  auto increment_and_print = [&counter]() {
    for (int i = 0; i < 3; i++) {
      counter.increment();
      std::cout << std::this_thread::get_id() << ' ' << counter.get() << '\n';
 
      // 注意：写入 std::cout 实际上也要由另一互斥同步。省略它以保持示例简洁。
    }
  };
 
  std::thread thread1(increment_and_print);
  std::thread thread2(increment_and_print);
 
  thread1.join();
  thread2.join();
}

// 解释：下列输出在单核机器上生成。 thread1 开始时，它首次进入循环并调用 increment() ，
// 随后调用 get() 。然而，在它能打印返回值到 std::cout 前，调度器将 thread1 置于休眠
// 并唤醒 thread2 ，它显然有足够时间一次运行全部三个循环迭代。再回到 thread1 ，它仍在首个
// 循环迭代中，它最终打印其局部的计数器副本的值，即 1 到 std::cout ，再运行剩下二个循环。
// 多核机器上，没有线程被置于休眠，且输出更可能为递增顺序。

可能的输出

139847802500864 1
139847802500864 2
139847802500864 3
139847794108160 4
139847794108160 5
139847794108160 6

std::shared_timed_mutex

它是从C++14 才提供的限时读写锁：std::shared_timed_mutex。
对比std::shared_mutex新增下面两个接口，其实这两个接口与上面讲到的std::timed_mutex的try_lock_for和try_lock_until类似。都是限时等待锁。只不过是增加了共享属性。

互斥锁

1. mutex，用于保证在任何时刻，都只能有一个线程访问该对象。 当获取锁操作失败时，线程会进入睡眠，等待锁释放时被唤醒。
2. 要么锁住、要么不锁住

读写锁

1. 相较于互斥锁，读写锁允许更高的并行性
2. 也称为“共享-独占锁”
3. 当处于写加锁时，在其解锁之前，所有尝试加锁线程都会阻塞
4. 当处于读加锁时，所有试图对其加锁的线程都可以得到访问权
5. 写锁会阻塞其它读写锁。当有一个线程获得写锁在写时，读锁也不能被其它线程获取；写者优先于读者（一旦有写者，则后续读者必须等待，唤醒时优先考虑写者）。适用于读取数据的频率远远大于写数据的频率的场合。

总结

1. 由于它们额外的复杂性，读/写锁std::shared_mutex， std::shared_timed_mutex优于普通锁std::mutex，std::timed_mutex的情况比较少见。但是理论上确实存在。
2. 如果在频繁但短暂的读取操作场景，读/写互斥不会提高性能。它更适合于读取操作频繁且耗时的场景。当读操作只是在内存数据结构中查找时，很可能简单的锁会胜过读/写锁。
3. 如果读取操作的开销非常大，并且您可以并行处理许多操作，那么在某些时候增加读写比率应该会导致读取/写入器性能优于排他锁的情况。断点在哪里取决于实际工作量。
4. 另请注意，在持有锁的同时执行耗时的操作通常是一个坏兆头。可能有更好的方法来解决问题，然后使用读/写锁。
5. 还要注意，在使用mutex时，要时刻注意lock()与unlock()的加锁临界区的范围，不能太大也不能太小，太大了会导致程序运行效率低下，大小了则不能满足我们对程序的控制。并且我们在加锁之后要及时解锁，否则会造成死锁，lock()与unlock()应该是成对出现。

参考文章

C++ 多线程：互斥量(mutex)_c++ 互斥-CSDN博客