std::unique_lock

来自cppreference.com
< cpp‎ | thread
 
 
并发支持库
线程
(C++11)
(C++20)
(C++20)
this_thread 命名空间
(C++11)
(C++11)
(C++11)
互斥
(C++11)
(C++11)  
通用锁管理
(C++11)
(C++11)
unique_lock
(C++11)
(C++11)
(C++11)
(C++11)
条件变量
(C++11)
信号量
闩与屏障
(C++20)
(C++20)
未来体
(C++11)
(C++11)
(C++11)
(C++11)
安全回收
(C++26)
(C++26)
风险指针





原子类型
(C++11)
(C++20)
原子类型的初始化
(C++11)(C++20 中弃用)
(C++11)(C++20 中弃用)
内存定序
原子操作的自由函数
原子标志的自由函数
 
 
在标头 <mutex> 定义
template< class Mutex >
class unique_lock;
(C++11 起)

unique_lock 是一种通用互斥包装器,允许延迟锁定、有时限的锁定尝试、递归锁定、所有权转移和与条件变量一同使用。

unique_lock 可移动,但不可复制——它满足可移动构造 (MoveConstructible) 可移动赋值 (MoveAssignable) 但不满足可复制构造 (CopyConstructible) 可复制赋值 (CopyAssignable)

unique_lock 满足可基本锁定 (BasicLockable) 的要求。如果 Mutex 满足可锁定 (Lockable) 的要求,那么 unique_lock 也满足可锁定 (Lockable) 的要求(例如:能用于 std::lock);如果 Mutex 满足可定时锁定 (TimedLockable) 的要求,那么 unique_lock 也满足可定时锁定 (TimedLockable) 的要求。

模板形参

Mutex - 要锁定的互斥体类型。此类型必须满足可基本锁定 (BasicLockable)

嵌套类型

类型 定义
mutex_type Mutex

成员函数

构造 unique_lock,可选地锁定提供的互斥体
(公开成员函数)
若占有关联互斥体,则解锁之
(公开成员函数)
若占有互斥体则解锁(即释放其所有权)之,并取得另一者的所有权
(公开成员函数)
锁定
锁定(即获取其所有权)关联互斥体
(公开成员函数)
尝试锁定(即获得其所有权)关联互斥体而不阻塞
(公开成员函数)
尝试锁定(即获得其所有权)关联的可定时锁定 (TimedLockable) 互斥体,若互斥体在给定时长中不可用则返回
(公开成员函数)
尝试锁定(即获得其所有权)关联可定时锁定 (TimedLockable) 互斥体,若抵达指定时间点互斥体仍不可用则返回
(公开成员函数)
解锁(即释放其所有权)关联互斥体
(公开成员函数)
修改器
与另一 std::unique_lock 交换状态
(公开成员函数)
将关联互斥体解除关联而不解锁(即释放其所有权)它
(公开成员函数)
观察器
返回指向关联互斥体的指针
(公开成员函数)
测试此锁是否占有(即已锁定)其关联互斥体
(公开成员函数)
测试此锁是否占有(即已锁定)其关联互斥体
(公开成员函数)

非成员函数

特化 std::swap 算法
(函数模板)

示例

#include <iostream>
#include <mutex>
#include <thread>
 
struct Box
{
    explicit Box(int num) : num_things{num} {}
 
    int num_things;
    std::mutex m;
};
 
void transfer(Box &from, Box &to, int num)
{
    // 仍未实际取锁
    std::unique_lock lock1{from.m, std::defer_lock};
    std::unique_lock lock2{to.m, std::defer_lock};
 
    // 在不死锁的情况下锁定两个 unique_lock
    std::lock(lock1, lock2);
 
    from.num_things -= num;
    to.num_things += num;
 
    // 互斥体 “from.m” 和 “to.m” 会在 unique_lock 析构函数中解锁
}
 
int main()
{
    Box acc1(100);
    Box acc2(50);
 
    std::thread t1(transfer, std::ref(acc1), std::ref(acc2), 10);
    std::thread t2(transfer, std::ref(acc2), std::ref(acc1), 5);
 
    t1.join();
    t2.join();
 
    std::cout << "acc1:" << acc1.num_things << "\n"
                 "acc2:" << acc2.num_things << '\n';
}

输出:

acc1:95
acc2:55

缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

缺陷报告 应用于 出版时的行为 正确行为
LWG 2981 C++17 提供来自 unique_lock<Mutex> 的冗余推导指引 已移除

参阅

(C++11)
锁定指定的互斥体,若任何一个不可用则阻塞
(函数模板)
实现严格基于作用域的互斥体所有权包装器
(类模板)
用于多个互斥体的免死锁 RAII 封装器
(类模板)
(C++11)
提供基本互斥设施
(类)