C++11 std::lock_guard

一 简介

头文件<mutex>

template< class Mutex >
class lock_guard;

The class lock_guard is a mutex wrapper that provides a convenient RAII-style mechanism for owning a mutex for the duration of a scoped block.

When a lock_guard object is created, it attempts to take ownership of the mutex it is given. When control leaves the scope in which the lock_guard object was created, the lock_guard is destructed and the mutex is released.

The lock_guard class is non-copyable.

即: 类 lock_guard 是互斥封装器,为在作用域块期间占有互斥提供了一种方便的RAII风格机制。
创建lock_guard对象时,它试图接收给定互斥的所有权。控制离开创建lock_guard对象的作用域时,销毁lock_guard并释放互斥。
lock_guard 类不可复制。

二 举例

例子1

#include <thread>
#include <mutex>
#include <iostream>

int g_i = 0;
std::mutex g_i_mutex;  // 保护 g_i

void safe_increment() {
  std::lock_guard<std::mutex> lock(g_i_mutex);
  ++g_i;

  std::cout << std::this_thread::get_id() << ": " << g_i << '\n';

  // g_i_mutex 在锁离开作用域时自动释放
}

int main() {
  std::cout << "main: " << g_i << '\n';

  std::thread t1(safe_increment);
  std::thread t2(safe_increment);

  t1.join();
  t2.join();

  std::cout << "main: " << g_i << '\n';
}

结果:

例子2

#include <thread>
#include <mutex>
#include <iostream>
#include <vector>

std::mutex g_mutex;  // 保护 vc
std::vector<int> vc;

void func() {

  // std::lock_guard<std::mutex> lock(g_mutex); 注意此句

  for(int i = 0; i < 100; ++i) 
  {
    vc.emplace_back(i);
  }

 std::cout << std::this_thread::get_id()  << std::endl;

  // g_mutex 在锁离开作用域时自动释放
}

int main() {
  std::cout << "main: " << vc.size() << '\n';

  std::thread t1(func);
  std::thread t2(func);

  t1.join();
  t2.join();

  std::cout << "main: " << vc.size() << '\n';

  getchar();
  return 0;
}

若不加锁,此时由于数据竞争,运行报错

若将 func 函数第一句代码放开,则运行正确:

三 参考

std::lock_guard

<think>嗯,用户想了解C++std::lock_guard的用法和相关问题。首先,我需要回忆一下std::lock_guard的基本概念。它是RAII(资源获取即初始化)机制的一部分,用于管理互斥量的锁定和解锁,确保在作用域结束时自动释放锁,避免死锁。 接下来,我应该考虑用户可能的实际需求。他们可能想知道如何正确使用lock_guard,比如在函数中保护共享资源。需要给出一个简单的例子,比如在多线程环境中对共享变量的操作。 然后,用户可能对lock_guardstd::mutex的关系不太清楚,需要解释它们如何配合使用。同时,用户可能想知道lock_guard的作用域范围,以及为什么它不可复制或移动,这些特性如何帮助避免资源泄漏。 另外,用户提到的引用[1]中涉及了std::unique_lock的使用,这可能暗示用户对不同类型的锁管理机制有疑问。需要比较lock_guard和unique_lock的区别,比如后者更灵活,支持延迟锁定和手动解锁,而前者更轻量,适用于简单的作用域锁定。 用户可能还需要了解lock_guard在异常安全中的作用,确保即使发生异常,互斥量也能正确释放。这可能涉及到在构造函数中锁定,析构函数中解锁的机制。 还要注意用户的问题中是否有关于多线程同步的其他方面,比如死锁避免,但根据问题,主要焦点应放在lock_guard的使用上。可能需要提醒用户,当需要同时锁定多个互斥量时,应使用std::lock配合std::adopt_lock策略,或者使用std::scoped_lockC++17之后)。 最后,生成相关问题时要覆盖常见的使用场景、与其他锁的区别、异常安全以及实际应用中的例子。确保问题能引导用户进一步深入学习,并解决他们可能遇到的实际问题。</think>### C++ std::lock_guard用法与示例 `std::lock_guard`是C++标准库中实现RAII(资源获取即初始化)的锁管理工具,用于自动管理互斥锁(`std::mutex`)的加锁与解锁,避免因异常或代码分支导致的未解锁问题。 --- #### 1. 基本用法 `std::lock_guard`在构造时锁定互斥量,析构时自动释放锁。 **示例:保护共享变量** ```cpp #include <mutex> #include <thread> std::mutex mtx; int shared_data = 0; void increment() { std::lock_guard<std::mutex> lock(mtx); // 构造时加锁 shared_data++; // 受保护操作 // 离开作用域时自动解锁 } int main() { std::thread t1(increment); std::thread t2(increment); t1.join(); t2.join(); return 0; } ``` --- #### 2. 核心特性 - **作用域绑定**:锁的生命周期与作用域一致。 - **不可复制/移动**:确保锁的所有权唯一[^1]。 - **异常安全**:即使发生异常,锁也会正确释放。 --- #### 3. 与`std::unique_lock`对比 | 特性 | `std::lock_guard` | `std::unique_lock` | |--------------------|------------------------|-----------------------------| | 灵活性 | 仅支持自动加锁/解锁 | 支持手动加锁/解锁、延迟锁定 | | 性能开销 | 更低 | 略高 | | 适用场景 | 简单作用域锁 | 复杂同步逻辑(如条件变量) | --- #### 4. 注意事项 - **避免嵌套锁**:同一线程重复加锁可能导致死锁。 - **配合`std::lock`使用**:需同时锁多个互斥量时,优先使用`std::lock`: ```cpp std::mutex mtx1, mtx2; void safe_op() { std::lock(mtx1, mtx2); // 同时锁定两个互斥量 std::lock_guard<std::mutex> lock1(mtx1, std::adopt_lock); std::lock_guard<std::mutex> lock2(mtx2, std::adopt_lock); // 操作共享资源 } ``` ---
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值