定义于头文件
<mutex>
class recursive_mutex; (C++11 起)
recursive_mutex
类是同步原语，能用于保护共享数据免受从个多线程同时访问。
recursive_mutex
提供排他性递归所有权语义：
-
调用方线程在从它成功调用
lock
或
try_lock
开始的时期里
占有
recursive_mutex
。此时期间，线程可以进行对
lock
或
try_lock
的附加调用。所有权的时期在线程调用
unlock
匹配次数时结束。 -
线程占有
recursive_mutex
时，若其他所有线程试图要求
recursive_mutex
的所有权，则它们将阻塞（对于调用
lock
）或收到 false 返回值（对于调用
try_lock
）。 -
可锁定
recursive_mutex
次数的最大值是未指定的，但抵达该数后，对
lock
的调用将抛出 std::system_error 而对
try_lock
的调用将返回 false 。
若
recursive_mutex
在仍为某线程占有时被销毁，则程序行为未定义。
recursive_mutex
类满足
互斥体
(Mutex) 和
标准布局类型
(StandardLayoutType) 的所有要求。
构造函数
recursive_mutex(); (1) (C++11 起)
recursive_mutex( const recursive_mutex& ) = delete; (2) (C++11 起)
1) 构造互斥。调用后互斥在未锁定状态。
2) 复制构造函数被删除。
参数
（无）
异常
若构造不成功则抛出 std::system_error 。
析构函数
~recursive_mutex();销毁互斥。
若互斥为任何线程占有，或若任何线程在保有任何互斥的所有权时终止，则行为未定义。
解锁互斥
void unlock(); (C++11 起)
若所有权等级为 1 （此线程对 lock() 的调用恰好比
unlock()
多一次 ）则解锁互斥，否则将所有权等级减少 1 。
互斥必须为当前执行线程所锁定，否则行为未定义。
此操作
同步于
（定义于 std::memory_order ）任何后继的取得同一互斥所有权的锁操作。
参数
（无）
返回值
（无）
异常
（无）
注意
通常不直接调用
unlock()
：用 std::unique_lock 与 std::lock_guard 管理排他性锁定。
锁定互斥，若互斥不可用则阻塞
void lock(); (C++11 起)
锁定互斥。若另一线程已锁定互斥，则到
lock
的调用将阻塞执行，直至获得锁。
线程可以在递归互斥上重复调用
lock
。在线程调用
unlock
匹配数量次后，所有权才会得到释放。
所有权的最大层数是未指定的。若超出此数，则可能抛 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::recursive_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';
std::this_thread::sleep_for(std::chrono::seconds(1));
}
for (int i = 0; i < 3; ++i)
{
g_num_mutex.unlock();
}
}
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 ，即使互斥当前未为任何其他线程所锁定。
线程可以重复调用
try_lock
。到
try_lock
的成功调用自增所有权计数：线程调用 unlock 匹配次数后互斥才会得到释放。
所有权层数的最大值是未指定的。若超出此数，则到
try_lock
的调用将返回 false 。
若此操作返回 true ，则同一互斥上的先前 unlock() 操作
同步于
（定义于 std::memory_order ）它。注意若此操作返回 false ，则先前的 lock() 不与之同步。
参数
（无）
返回值
若成功取得锁则为 true ，否则为 false 。
异常
（无）
调用示例
#include <iostream>
#include <mutex>
int main()
{
std::recursive_mutex test;
if (test.try_lock()==true) {
std::cout << "lock acquired" << std::endl;
test.unlock(); // 现在锁定互斥
} else {
std::cout << "lock not acquired" << std::endl;
}
test.lock(); // 再锁定它
if (test.try_lock()) { // 可留下 true
std::cout << "lock acquired" << std::endl;
} else {
std::cout << "lock not acquired" << std::endl;
}
test.unlock();
}
输出
