命名空间
变体
操作

std::unique_lock

来自 cppreference.cn
< cpp‎ | thread
 
C++
 
并发支持库
线程
(C++11)
(C++20)
(C++17)(C++17)
this_thread 命名空间
(C++11)
(C++11)
(C++11)
(C++11)
协作取消
互斥
(C++11)
(C++11)
(C++17)
通用锁管理
(C++11)
(C++11)
(C++17)
unique_lock
(C++11)
(C++14)
(C++11)
(C++11)
(C++11)
(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)
条件变量
(C++11)
(C++11)
(C++11)
(C++11)
信号量
(C++20)(C++20)
闩锁和屏障
(C++20)
(C++20)
期物
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
安全回收
(C++26)
(C++26)
(C++26)
hazard 指针
(C++26)
(C++26)
(C++26)
原子类型
(C++11)
(C++20)
(C++11)
原子类型的初始化
(C++11)(在 C++20 中弃用)
(C++11)(在 C++20 中弃用)
(C++11)
内存顺序
(C++11)
(C++11)(在 C++26 中弃用)
(C++11)
(C++11)
原子操作的自由函数
(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)
(C++26)(C++26)
(C++26)(C++26)
(C++11)
(C++20)(C++20)
(C++20)
(C++20)
原子标志的自由函数
(C++11)(C++11)
(C++11)(C++11)
(C++20)(C++20)
(C++20)(C++20)
(C++20)
(C++20)
 
std::unique_lock
 
定义于头文件 <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 交换状态
(公共成员函数) [编辑]
 解除关联的互斥量，但不解锁（即，不释放所有权）它
(公共成员函数) [编辑]
观察器
 返回指向关联互斥量的指针
(公共成员函数) [编辑]
 测试锁是否拥有（即，已锁定）其关联的互斥量
(公共成员函数) [编辑]
 测试锁是否拥有（即，已锁定）其关联的互斥量
(公共成员函数) [编辑]

[编辑] 非成员函数

(C++11)
 特化 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)
 锁定指定的互斥量，如果有任何互斥量不可用则阻塞
(函数模板) [编辑]
(C++11)
 实现一个严格基于作用域的互斥量所有权包装器
(类模板) [编辑]
(C++17)
 用于多个互斥量的避免死锁的 RAII 包装器
(类模板) [编辑]
(C++11)
 提供基本的互斥设施
(类) [编辑]
取自“https://cppreference.cn/mwiki/index.php?title=cpp/thread/unique_lock&oldid=169985”