std:mutex
在 C++ 中，mutex 类能用于保护共享数据从多个线程同时访问的同步原语。
mutex 提供排他性非递归所有权语义：
- 调用方线程从它成功调用 lock 或者 try_lock 开始，到它调用 unlock 为止，占用该 mutex
- 调用线程占用 mutex，所有其它线程试图要求 mutex 的所有权，如果请求线程调用 lock(),则将阻塞;如果请求线程调用 try_lock() 则返回 false。
如果 mutex 在被线程占用的时候被销毁，或者占用 mutex 的时候线程终止，则行为未定义。
mutex 的类信息如下：
| (构造函数) | 构造互斥 (公开成员函数) |
|---|---|
| (析构函数) | 销毁互斥 (公开成员函数) |
| operator=[被删除] | 不可复制赋值 (公开成员函数) |
| 锁定 | |
| lock | 锁定互斥，若互斥不可用则阻塞 (公开成员函数) |
| try_lock | 尝试锁定互斥，若互斥不可用则返回 (公开成员函数) |
| unlock | 解锁互斥 (公开成员函数) |
| 原生句柄 | |
| native_handle | 返回底层实现定义的原生句柄 (公开成员函数) |
在实际的开发中，不会直接使用 mutex ，而是使用 std:unique_lock,std::lock_guard,std::scoped_lock 等方式进行加锁。
std::recursive_mutex
和 std::mutex 一样，但是 std::recursive_mutex 允许同一个线程对互斥量多次上锁，也就是递归上锁，来获得互斥对象的多层所有权，同时释放互斥量也要调用锁深度层次相同的 unlock() 方法。
std::time_mutex
std::time_mutex 比 std::mutex 多了两个成员函数，try_lock_for()，try_lock_until()。
try_lock_for() 表示函数接受一个时间范围，也就是在这个时间段范围内没有获取锁，则该线程被阻塞。
try_lock_until 函数则接受一个时间点作为参数，在指定时间点未到来之前线程如果没有获得锁则被阻塞住，如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超时（即在指定时间内还是没有获得锁），则返回 false。
示例代码如下：
#include
#include
#include
std::timed_mutex t_mutex;
void fire_work() {
//try_lock_for 会等待一段时间，
while (!t_mutex.try_lock_for(chrono::milliseconds(200))) {
std::cout << "-";
}
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
cout << "*\n";
t_mutex.unlock();
}
int main() {
std::thread threads[10];
// spawn 10 threads:
for (int i = 0; i < 10; ++i)
threads[i] = std::thread(fire_work);
for (auto &th : threads) th.join();
return 0;
}
最后控制台输入如下：
------------------------------------*
----------------------------------------*
-----------------------------------*
------------------------------*
-------------------------*
--------------------*
---------------*
----------*
-----*
*
示例代码中，启动了十个线程,然后每个线程都会对互斥信号量 t_mutex，请求 lock。第一个线程，拿到了 lock，然后直接打印了 *,第二个线程，try_lock 会等待 200 。
std::lock_guard
源码位于头文件
该类是互斥体的包装器，为在作用域块期间内占用互斥提供便利的 RAII 风格机制，也就是资源获取即初始化机制。
从逻辑上来说，创建 lock_guard() 对象时，它试图接受给定互斥的所有权。控制离开创建 lock_guard 对象的作用域时，销毁 lock_guard 并且是否互斥。
简单例子如下：
#include
#include
//声明空间
using namespace std;
int g_i = 0;
mutex g_i_mutex;//定义一个互斥信息
void safe_increment() {
//创建 lock_guard 对象，并且使用g_i_mutex 作为构造函数参数
//在整个方法作用域里面，这锁都是生效的
lock_guard lock(g_i_mutex);
//操作需要互斥的变量之前，先创建 lock_guard 对象
g_i++;
}
int main() {
thread t1(safe_increment);
thread t2(safe_increment);
t1.join();
t2.join();
}
lock_grard 的原理很简单，在对象的构造函数中，调用 mutex.lock()，然后在析构函数中，调用 unlock(),源码如下：
explicit lock_guard(mutex_type& __m) _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability(__m))
: __m_(__m) {__m_.lock();}
lock_guard(mutex_type& __m, adopt_lock_t) _LIBCPP_THREAD_SAFETY_ANNOTATION(requires_capability(__m))
: __m_(__m) {}
~lock_guard() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability()) {__m_.unlock();}
std::unique_lock
源码位于头文件
和 std::lock_guard() 类似，但是提供了更好的上锁机制和解锁控制。包含了 try_lock_for() 和 try_lock_unitl() 两个方法，可以指定等待锁的时间。
类的相关信息如下：
| (构造函数) | 构造 unique_lock ，可选地锁定提供的互斥 (公开成员函数) |
|---|---|
| (析构函数) | 若占有关联互斥，则解锁之 (公开成员函数) |
| operator= | 若占有则解锁互斥，并取得另一者的所有权 (公开成员函数) |
| 锁定 | |
| lock | 锁定关联互斥 (公开成员函数) |
| try_lock | 尝试锁定关联互斥，若互斥不可用则返回 (公开成员函数) |
| try_lock_for | 试图锁定关联的可定时锁定 (TimedLockable) 互斥，若互斥在给定时长中不可用则返回 (公开成员函数) |
| try_lock_until | 尝试锁定关联可定时锁定 (TimedLockable) 互斥，若抵达指定时间点互斥仍不可用则返回 (公开成员函数) |
| unlock | 解锁关联互斥 (公开成员函数) |
| 修改器 | |
| swap | 与另一 std::unique_lock 交换状态 (公开成员函数) |
| release | 将关联互斥解关联而不解锁它 (公开成员函数) |
| 观察器 | |
| mutex | 返回指向关联互斥的指针 (公开成员函数) |
| owns_lock | 测试锁是否占有其关联互斥 (公开成员函数) |
| operator bool | 测试锁是否占有其关联互斥 (公开成员函数) |
示例代码如下，以一个银行转账的业务为例子：
void transfer(bank_account &from, bank_account &to, int amount) {
//defer_lock 表示延迟加锁,实际上未获取锁
unique_lock lock1(from.mMutex, defer_lock);
unique_lock lock2(to.mMutex, defer_lock);
//获取锁
lock(lock1, lock2);
from.iMoney -= amount;
to.iMoney += amount;
}
void test_transfer() {
bank_account Account1("User1", 100);
bank_account Account2("User2", 50);
thread t1([&]() { transfer(Account1, Account2, 10); });//lambda表达式
thread t2([&]() { transfer(Account2, Account1, 5); });
t1.join();
t2.join();
}
参考
RAII