锁

锁是用来防止不同线程访问同一个共享资源时发生数据竞争风险，保证访问的先后顺序而达到数据的一致性访问。本文介绍的 lock_guard 和 unique_lock，都是对 std::mutex 进行封装，实现 RAII 的效果。这两种锁本质差不多，而 unique_lock 的功能比 lock_guard 多一些。

lock_guard

lock_guard 用来管理一个 std::mutext 类型的对象，定义一个 lock_guard 对象同时调用构造函数，对 std::mutex 进行上锁，退出作用域时析构，从而进行解锁。

1	std::lock_guard<std::mutex> lock(mutex_name);

特点如下：

创建即加锁，退出作用域自动解锁，避免忘记解锁。
无需手工解锁。不能中途解锁。
无法复制。
并不管理 std::mutex 的生命周期，如果在作用域内的时候 std::mutex 被释放了，那就会出现空指针错误。

使用示例：

#include <thread>
#include <mutex>
#include <iostream>
 
int g_i = 0;
std::mutex g_i_mutex;  
 
void safe_increment() {
    const std::lock_guard<std::mutex> lock(g_i_mutex);
    ++g_i;
    std::cout << std::this_thread::get_id() << ": " << g_i << std::endl;
}
 
int main() {
    std::cout << "start: " << g_i << '\n';
    std::thread t1(safe_increment);
    std::thread t2(safe_increment);
    t1.join();
    t2.join();
    std::cout << "end: " << g_i << '\n';
}

输出：

@└────> # ./a.out 
start: 0
140365627524864: 1
140365619132160: 2
end: 2

unique_lock

虽然 lock_guard 挺好用的，但是有个很大的缺陷，在定义 lock_guard 的地方会调用构造函数加锁，在离开定义域的话 lock_guard 就会被销毁，调用析构函数解锁。这就产生了一个问题，如果这个定义域范围很大的话，那么锁的粒度就很大，很大程序上会影响效率。
所以为了解决 lock_guard 锁的粒度过大的问题，unique_lock 就出现了。

方法	说明	详细说明
`explicit unique_lock(mutex_type& m);`	加锁	新创建的 unique_lock 对象，管理 Mutex 对象 m，并尝试调用 m.lock() 对 Mutex 对象进行上锁，如果此时另外某个 unique_lock 对象已经管理了该 Mutex 对象 m，则当前线程将会被阻塞。
`unique_lock(mutex_type& m, try_to_lock_t tag);`	尝试加锁	try-locking 初始化新创建的 unique_lock 对象，管理 Mutex 对象 m，并尝试调用 m.try_lock() 对 Mutex 对象进行上锁，但如果上锁不成功，并不会阻塞当前线程。
`unique_lock(mutex_type& m, defer_lock_t tag) noexcept;`	延迟加锁	初始化新创建的 unique_lock 对象，管理 Mutex 对象 m，但是在初始化的时候并不锁住 Mutex 对象。 m 应该是一个没有当前线程锁住的 Mutex 对象。
`unique_lock(mutex_type& m, adopt_lock_t tag);`	递归加锁	初始化新创建的 unique_lock 对象管理 Mutex 对象 m， m 应该是一个已经被当前线程锁住的 Mutex 对象。(并且当前新创建的 unique_lock 对象拥有对锁(Lock)的所有权)。

特点如下：

创建时可以不锁定（通过指定第二个参数为 std::defer_lock），而在需要时再锁定。
可以随时加锁解锁（调用 lock 或者 unlock 成员函数）。
作用域规则同 lock_grard，析构的时候会判断当前锁的状态来决定是否解锁，如果当前状态已经是解锁状态了，那么就不会再次解锁，而如果当前状态是加锁状态，就会自动调用unique.unlock()来解锁。
不可复制，可移动
条件变量需要该类型的锁作为参数（此时必须使用 unique_lock）

1 2	condition_variable cv; cv.wait(unique_lock); // 会做两件事1：使线程进入等待状态 2:unique_lock.unlock 把mtx给释放掉

unique_lock 示例：

#include <mutex>
#include <thread>
#include <chrono>
#include <iostream>
 
struct Box {
    explicit Box(int num) : num_things{num} {}
    int num_things;
    std::mutex m;
};
 
void transfer(Box &from, Box &to, int num) {
    std::unique_lock<std::mutex> lock1(from.m, std::defer_lock);
    std::unique_lock<std::mutex> lock2(to.m, std::defer_lock);
    std::lock(lock1, lock2);
    from.num_things -= num;
    to.num_things += num; 
}
 
int main() {
    Box box1(100);
    Box box2(50);
    std::thread t1(transfer, std::ref(box1), std::ref(box2), 10);
    std::thread t2(transfer, std::ref(box2), std::ref(box1), 5);
    t1.join();
    t2.join();
    std::cout << "box1:" << box1.num_things << std::endl;
    std::cout << "box2:" << box2.num_things << std::endl;
}

1
2
3

@└────> # ./a.out 
box1:95
box2:55

总结

unique_lock 内部会维护一个锁的状态，所以在效率上肯定会比 lock_guard 慢。所以在能使用 lock_guard 的情况下尽量优先使用 lock_guard。

caijizhuo

cpp之lock_guard和unique_lock

锁

lock_guard

unique_lock

总结