C++

参考

<mutex>

lock_guard

类模板
<mutex>

std::lock_guard

template <class Mutex> class lock_guard;
Lock guard
一个 lock guard 是一个对象，它通过一直锁定来管理一个 mutex object。

在构造时，mutex object 会被调用线程锁定，在析构时，mutex 会被解锁。它是最简单的锁，特别适用于具有自动存储期并在其上下文结束时销毁的对象。通过这种方式，它保证了在抛出异常时 mutex object 会被正确解锁。

但请注意，lock_guard 对象不以任何方式管理 mutex object 的生命周期：mutex object 的生命周期至少应延长到锁定它的 lock_guard 的析构。

模板参数

互斥体
一个 mutex-like type。
它应该是basic lockable type，例如 mutex (有关要求，请参阅 BasicLockable)。

成员类型

成员类型定义描述
mutex_type模板参数 ( Mutex)被管理的 mutex object 类型

成员函数

（构造函数）
Construct lock_guard (public member function)
(析构函数)
Destroy lock_guard (unlocking mutex) (public member function)


示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
// lock_guard example
#include <iostream>       // std::cout
#include <thread>         // std::thread
#include <mutex>          // std::mutex, std::lock_guard
#include <stdexcept>      // std::logic_error

std::mutex mtx;

void print_even (int x) {
  if (x%2==0) std::cout << x << " is even\n";
  else throw (std::logic_error("not even"));
}

void print_thread_id (int id) {
  try {
    // using a local lock_guard to lock mtx guarantees unlocking on destruction / exception:
    std::lock_guard<std::mutex> lck (mtx);
    print_even(id);
  }
  catch (std::logic_error&) {
    std::cout << "[exception caught]\n";
  }
}

int main ()
{
  std::thread threads[10];
  // spawn 10 threads:
  for (int i=0; i<10; ++i)
    threads[i] = std::thread(print_thread_id,i+1);

  for (auto& th : threads) th.join();

  return 0;
}

可能的输出
[exception caught]
2 is even
[exception caught]
4 is even
[exception caught]
6 is even
[exception caught]
8 is even
[exception caught]
10 is even


打印的行顺序可能不同。

另见

unique_lock
Unique lock (class template)