std::lock_guard

定义在头文件 `<mutex>` 中
template< class Mutex > class lock_guard;		(自 C++11 起)

lock_guard 类是一个互斥量包装器，它提供了一种方便的 RAII 风格机制，用于在作用域块的持续时间内拥有互斥量。

当创建 lock_guard 对象时，它会尝试获取它被赋予的互斥量的所有权。当控制权离开创建 lock_guard 对象的作用域时，lock_guard 被销毁，并且互斥量被释放。

lock_guard 类不可复制。

内容

1 模板参数
2 成员类型
3 成员函数
4 说明
5 示例
6 缺陷报告
7 另请参阅

[编辑] 模板参数

Mutex

-

要锁定的互斥量的类型。该类型必须满足 BasicLockable 要求

[编辑] 成员类型

成员类型	定义
`mutex_type`	Mutex

[编辑] 成员函数

(构造函数)	构造一个 `lock_guard`，可选地锁定给定的互斥量 (公共成员函数) [编辑]
(析构函数)	析构 `lock_guard` 对象，解锁底层互斥量 (公共成员函数) [编辑]
operator= [已删除]	不可复制赋值 (公共成员函数) [编辑]

[编辑] 说明

一个常见的初学者错误是“忘记”给 lock_guard 变量起一个名字，例如 std::lock_guard(mtx);（它默认构造一个名为 mtx 的 lock_guard 变量）或 std::lock_guard{mtx};（它构造一个立即被销毁的右值对象），从而实际上没有构造一个锁来持有剩余作用域的互斥量。

std::scoped_lock 为 lock_guard 提供了一个替代方案，它提供了使用死锁避免算法锁定多个互斥量的能力。

(自 C++17 起)

[编辑] 示例

演示了两个线程对易失性变量的安全和不安全增量。

运行此代码

#include <iostream>
#include <mutex>
#include <string_view>
#include <syncstream>
#include <thread>
 
volatile int g_i = 0;
std::mutex g_i_mutex;  // protects g_i
 
void safe_increment(int iterations)
{
    const std::lock_guard<std::mutex> lock(g_i_mutex);
    while (iterations-- > 0)
        g_i = g_i + 1;
    std::cout << "thread #" << std::this_thread::get_id() << ", g_i: " << g_i << '\n';
 
    // g_i_mutex is automatically released when lock goes out of scope
}
 
void unsafe_increment(int iterations)
{
    while (iterations-- > 0)
        g_i = g_i + 1;
    std::osyncstream(std::cout) << "thread #" << std::this_thread::get_id()
                                << ", g_i: " << g_i << '\n';
}
 
int main()
{
    auto test = [](std::string_view fun_name, auto fun)
    {
        g_i = 0;
        std::cout << fun_name << ":\nbefore, g_i: " << g_i << '\n';
        {
            std::jthread t1(fun, 1'000'000);
            std::jthread t2(fun, 1'000'000);
        }
        std::cout << "after, g_i: " << g_i << "\n\n";
    };
    test("safe_increment", safe_increment);
    test("unsafe_increment", unsafe_increment);
}

可能的输出

safe_increment:
before, g_i: 0
thread #140121493231360, g_i: 1000000
thread #140121484838656, g_i: 2000000
after, g_i: 2000000
 
unsafe_increment:
before, g_i: 0
thread #140121484838656, g_i: 1028945
thread #140121493231360, g_i: 1034337
after, g_i: 1034337

[编辑] 缺陷报告

以下行为更改缺陷报告已追溯应用于以前发布的 C++ 标准。

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

[编辑] 另请参阅

unique_lock (C++11)	实现可移动互斥量所有权包装器 (类模板) [编辑]
scoped_lock (C++17)	用于多个互斥量的死锁避免 RAII 包装器 (类模板) [编辑]

编译器支持
独立和托管
语言
标准库
标准库头文件
命名要求
特性测试宏 (C++20)
语言支持库
概念库 (C++20)
元编程库 (C++11)
诊断库
通用实用程序库
字符串库
容器库
迭代器库
范围库 (C++20)
算法库
数值库
本地化库
输入/输出库
文件系统库 (C++17)
正则表达式库 (C++11)
并发支持库 (C++11)
执行支持库 (C++26)
技术规范
符号索引
外部库

cppreference.com

命名空间

变体

视图

操作