命名空间
变体
操作

std::unique_lock

来自 cppreference.com
< cpp‎ | thread
 
 
并发支持库
线程
(C++11)
(C++20)
this_thread 命名空间
(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++11)
(C++20)
原子类型的初始化
(C++11)(C++20 中已弃用)
(C++11)(C++20 中已弃用)
内存排序
原子操作的自由函数
原子标志的自由函数
 
 
定义在头文件 <mutex>
template< class Mutex >
class unique_lock;
(自 C++11 起)

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

unique_lock 是可移动的,但不可复制——它满足 MoveConstructibleMoveAssignable 的要求,但不满足 CopyConstructibleCopyAssignable 的要求。

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)
{
    // don't actually take the locks yet
    std::unique_lock lock1{from.m, std::defer_lock};
    std::unique_lock lock2{to.m, std::defer_lock};
 
    // lock both unique_locks without deadlock
    std::lock(lock1, lock2);
 
    from.num_things -= num;
    to.num_things += num;
 
    // “from.m” and “to.m” mutexes unlocked in unique_lock dtors
}
 
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++ 标准。

DR 应用于 发布的行为 正确的行为
LWG 2981 C++17 提供了来自 unique_lock<Mutex> 的冗余推导指南 已删除

[编辑] 另请参见

(C++11)
锁定指定的互斥锁,如果任何互斥锁不可用,则阻塞
(函数模板) [编辑]
实现严格的基于范围的互斥锁所有权包装器
(类模板) [编辑]
用于多个互斥锁的避免死锁的 RAII 包装器
(类模板) [编辑]
(C++11)
提供基本的互斥设施
(类) [编辑]