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 <mutex>
#include <thread>
#include <iostream>
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
源码位于头文件 <mutex> 中,template<class Mutex> class lock_grard
该类是互斥体的包装器,为在作用域块期间内占用互斥提供便利的 RAII 风格机制,也就是资源获取即初始化机制。
从逻辑上来说,创建 lock_guard() 对象时,它试图接受给定互斥的所有权。控制离开创建 lock_guard 对象的作用域时,销毁 lock_guard 并且是否互斥。
简单例子如下:
#include <mutex>
#include <thread>
//声明空间
using namespace std;
int g_i = 0;
mutex g_i_mutex;//定义一个互斥信息
void safe_increment() {
//创建 lock_guard 对象,并且使用g_i_mutex 作为构造函数参数
//在整个方法作用域里面,这锁都是生效的
lock_guard<std::mutex> lock(g_i_mutex);
//操作需要互斥的变量之前,先创建 lock_guard<std::mutex> 对象
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
源码位于头文件 <mutex> 中,template<class Mutex> class 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<mutex> lock1(from.mMutex, defer_lock);
unique_lock<mutex> 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();
}
参考
网友评论