定义于头文件 <mutex>
class mutex; (C++11 起)
mutex
类是能用于保护共享数据免受从多个线程同时访问的同步原语。
mutex
提供排他性非递归所有权语义:
- 调用方线程从它成功调用
lock
或try_lock
开始,到它调用unlock
为止占有mutex
。 - 线程占有
mutex
时,所有其他线程若试图要求mutex
的所有权,则将阻塞(对于lock
的调用)或收到 false 返回值(对于try_lock
). - 调用方线程在调用
lock
或try_lock
前必须不占有mutex
。
若 mutex
在仍为任何线程所占有时即被销毁,或在占有 mutex
时线程终止,则行为未定义。 mutex
类满足互斥体 (Mutex) 和标准布局类型 (StandardLayoutType) 的全部要求。
std::mutex
既不可复制亦不可移动。
构造互斥
mutex(); (1) (C++11 起)
mutex( const mutex& ) = delete; (2) (C++11 起)
1) 构造互斥。调用后互斥在未锁定状态。
2) 复制构造函数被删除。
参数
(无)
异常
若构造不成功则抛出 std::system_error 。
解锁互斥
void unlock(); (C++11 起)
解锁互斥。
互斥必须为当前执行线程所锁定,否则行为未定义。
此操作同步于(定义于 std::memory_order )任何后继的取得同一互斥所有权的锁操作。
参数
(无)
返回值
(无)
异常
(无)
注意
通常不直接调用 unlock()
:用 std::unique_lock 与 std::lock_guard 管理排他性锁定。
锁定互斥,若互斥不可用则阻塞
void lock(); (C++11 起)
锁定互斥。若另一线程已锁定互斥,则到 lock
的调用将阻塞执行,直至获得锁。
若 lock
为已占有 mutex
的线程调用,则行为未定义:例如,程序可能死锁。鼓励能检测非法使用的实现抛出以 resource_deadlock_would_occur
为错误条件的 std::system_error ,而不是死锁。
同一互斥上先前的 unlock() 操作同步于(定义于 std::memory_order )此操作。
参数
(无)
返回值
(无)
异常
错误发生时抛出 std::system_error ,包括底层操作系统阻止 lock
满足其规定的错误。在抛出任何异常的情况下,不锁定互斥。
注意
通常不直接调用 lock()
:用 std::unique_lock 与 std::lock_guard 管理排他性锁定。
调用示例
#include <iostream>
#include <chrono>
#include <thread>
#include <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 << 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();
}
可能的输出
尝试锁定互斥,若互斥不可用则返回
bool try_lock(); (C++11 起)
尝试锁定互斥。立即返回。成功获得锁时返回 true ,否则返回 false 。
允许此函数虚假地失败而返回 false ,即使互斥当前未为任何其他线程所锁定。
若已占有 mutex
的线程调用 try_lock
,则行为未定义。
若此操作返回 true ,则同一互斥上的先前 unlock() 操作同步于(定义于 std::memory_order )它。注意若此操作返回 false ,则先前的 lock() 不与之同步。
参数
(无)
返回值
若成功取得锁则为 true ,否则为 false 。
异常
(无)
调用示例
#include <chrono>
#include <mutex>
#include <thread>
#include <iostream> // std::cout
std::chrono::milliseconds interval(100);
std::mutex smutex;
int job_shared = 0; // 两个线程都能修改 'job_shared',
// mutex 将保护此变量
int job_exclusive = 0; // 只有一个线程能修改 'job_exclusive'
// 不需要保护
// 此线程能修改 'job_shared' 和 'job_exclusive'
void job_1()
{
std::this_thread::sleep_for(interval); // 令 'job_2' 持锁
while (true)
{
// 尝试锁定 mutex 以修改 'job_shared'
if (smutex.try_lock())
{
std::cout << "job shared (" << job_shared << ")\n";
smutex.unlock();
return;
}
else
{
// 不能获取锁以修改 'job_shared'
// 但有其他工作可做
++job_exclusive;
std::cout << "job exclusive (" << job_exclusive << ")\n";
std::this_thread::sleep_for(interval);
}
}
}
// 此线程只能修改 'job_shared'
void job_2()
{
smutex.lock();
std::this_thread::sleep_for(5 * interval);
++job_shared;
smutex.unlock();
}
int main()
{
std::thread thread_1(job_1);
std::thread thread_2(job_2);
thread_1.join();
thread_2.join();
}
可能的输出