C++11特性：std::lock_guard是否会引起死锁？

今天在评审代码的时候，因为位于两个不同的线程中（一个是周期性事件线程，一个是触发式事件线程），需要对一个资源类的某些属性进行互斥的访问，因此采用lock_guard互斥量包装器，但是在升级的过程中，因为整个系统太大，所以在询问了某位同事后，得到的答案是在两个不同的地方加上lock_guard有一定的可能性会导致死锁，但是后面在测试的过程中又没有问题，真的如此吗？本文针对lock_guard来做阐述和延申

历史原因：为什么要使用lock_gurad，有什么优点

传统的C++对互斥量加锁是用互斥量本身的锁的，即

#include <mutex>std::mutex g_mutex;// 加锁
g_mutex.lock();
// 解锁
g_mutex.unlock();

此时会有两个不便利处，即要手动的解锁，如果忘了解锁，那就完蛋了！，因此采用lock_guard

#include <mutex>std::mutex g_mutex;{ // 作用域开始std::lock_guard<std::mutex> lock(g_mutex);
} // 作用域结束

lock_guard以作用域为加解锁单位，退出当前作用域自动解锁，不必手动解锁。总结一下它的优点

• RAII（资源获取即初始化）语法：std::lock_guard 使用对象的构造函数和析构函数来自动管理互斥量的锁定和解锁，从而避免了手动管理锁的复杂性。这种自动化的资源管理方式确保在作用域结束时释放锁，防止忘记解锁而导致的资源泄漏或死锁
• 异常安全：由于 std::lock_guard 使用RAII语法，即使在作用域内发生异常，也会自动调用析构函数释放锁，确保了异常安全性。这样可以避免在异常发生时锁没有被释放而导致的资源泄漏或死锁
• 简单易用：std::lock_guard 提供了一种简单而直观的方式来管理互斥量，不需要手动调用 lock() 和 unlock() 函数，因此代码更加简洁清晰，易于理解和维护
• 避免死锁：由于 std::lock_guard 在构造时立即锁定互斥量，在析构时立即释放互斥量，因此减少了出现死锁的可能性。通过使用 std::lock_guard，程序员可以更容易地确保正确的加锁和解锁顺序，从而避免死锁
• 线程安全性：std::lock_guard 是线程安全的，可以在多线程环境下安全地使用。它能够确保在同一时间只有一个线程可以访问被互斥量保护的资源，从而保证了线程安全性

lock_guard和unique_lock的区别

延迟加锁：可以在构造时不立即锁定互斥量，在需要时手动调用 lock() 函数来锁定互斥量。这种延迟加锁的特性允许在一段代码中多次锁定和解锁互斥量，提供了更多的灵活性

void FunThread()
{std::unique_lock<std::mutex> lock(mtx, std::defer_lock); // 延迟加锁，此时不加锁lock.lock(); // 加锁//lock.unlock(); // 解锁
}

条件等待：提供了与条件变量一起使用的功能，可以在条件变量的等待和通知过程中自动锁定和解锁互斥量。通过将 std::unique_lock 对象传递给条件变量的wait()和 notify_*() 函数，可以轻松实现条件等待的功能

配合条件变量使用的时候必须使用unique_lock，因此lock_guard不会自动释放锁，试想，在wait之前，本线程已经持有锁了，在等待的时候，如果一直持有互斥量，那其他线程也会拿不到互斥量，执行不了逻辑，则会导致永久死锁，可见源码

    template <class _Lock, class _Predicate>bool wait(_Lock& __lock,stop_token __stoken,_Predicate __p){if (__stoken.stop_requested()){return __p();}std::stop_callback __cb(__stoken, [this] { notify_all(); });shared_ptr<mutex> __mutex = _M_mutex;while (!__p()){unique_lock<mutex> __my_lock(*__mutex);if (__stoken.stop_requested()){return false;}// *__mutex must be unlocked before re-locking __lock so move// ownership of *__mutex lock to an object with shorter lifetime._Unlock<_Lock> __unlock(__lock); // 先解锁unique_lock<mutex> __my_lock2(std::move(__my_lock));_M_cond.wait(__my_lock2);}return true;}

{std::unique_lock<std::mutex> lock(g_mutex);g_condition.wait(lock, [] { // condition }); // 等待队列不为空的才去获得锁
}

所有权转移：支持所有权转移，允许将互斥量的所有权从一个std::unique_lock对象转移到另一个对象。这使得在一段代码中传递互斥量的所有权变得更加方便

void Fun2(std::unique_lock<std::mutex> lock)
{// 手动解锁锁lock.unlock();
}
void Fun1()
{std::unique_lock<std::mutex> lock(mtx);std::thread F(Fun2, std::move(lock));
}

性能损失：与 std::lock_guard 相比，std::unique_lock 有一些性能损失，因为它需要更多的控制和管理互斥量的状态，包括手动加锁、解锁和条件等待。但是，这种性能损失通常是微不足道的，并且可以通过使用std::defer_lock 参数来避免

还有一个scope_lock，在此不做介绍

lock_guard小demo：读写队列

/** @Author: LiuHao* @Date: 2024-03-24 01:40:15* @Description: 测试C++的互斥量包装器*/#include <thread>
#include <mutex>
#include <iostream>
#include <deque>
#include <vector>
#include <condition_variable>std::mutex g_mutex; // 互斥量
std::deque<uint8_t> g_deque; // 双端队列
std::condition_variable g_condition; // 条件变量namespace LHSpace { // 解决cout不能直接输出uint8_t的值的问题class LHCout {public:template <typename T>typename std::enable_if<std::is_same<T, uint8_t>::value, LHCout&>::type operator<<(const T& num){std::cout << static_cast<int>(num);return *this;}LHCout& operator<<(std::ostream& (*manipulator)(std::ostream&)){std::cout << manipulator;return *this;}};
}

demo组成

• 十个写线程
• 一个循环读线程

写线程函数

void SetPrint(const uint8_t val)
{LHSpace::LHCout lhCout;{std::lock_guard<std::mutex> lock(g_mutex);std::cout << "Write Thread ID: " << std::this_thread::get_id() << std::endl;g_deque.push_back(val); // 末尾添加一个元素std::cout << "deque push: ";lhCout << val << std::endl;}g_condition.notify_one(); // 使用条件变量std::this_thread::sleep_for(std::chrono::seconds(1));
}

读线程函数

void GetPrint()
{LHSpace::LHCout lhCout;while (true) { // 每一次退出作用域就丢掉锁std::unique_lock<std::mutex> lock(g_mutex);g_condition.wait(lock, [] { return !g_deque.empty(); }); // 等待队列不为空的才去获得锁const uint8_t FRONTNUM = g_deque.front();g_deque.pop_front();lock.unlock();std::cout << "Read Thread ID: " << std::this_thread::get_id() << std::endl;std::cout << "deque pop: ";lhCout << FRONTNUM << std::endl;std::this_thread::sleep_for(std::chrono::milliseconds(500));}
}

创建并启动线程

int main(int argc, const char** argv)
{LHSpace::LHCout lhCout;std::vector<std::thread> writeThreads;for (uint8_t i = 0U; i < 10U; i++) {writeThreads.push_back(std::thread(SetPrint, i)); // 读线程}std::thread getThread(GetPrint); // 读线程for (uint8_t i = 0U; i < 10U; i++) {writeThreads[i].join();}getThread.join();return 0;
}

来看看具体运行过程，感受一下多线程的魅力

ubuntu@VM-8-16-ubuntu:~/tmp$ ./a.out 
Write Thread ID: 140363031643712
deque push: 2 # 写
Write Thread ID: 140363023251008
deque push: 3 # 写
Read Thread ID: 140362964502080
deque pop: 2 # 读
Write Thread ID: 140363040036416
deque push: 1 # 写
Write Thread ID: 140363048429120
deque push: 0 # 写
Write Thread ID: 140363014858304
deque push: 4 # 写
Read Thread ID: 140362964502080
deque pop: 3 # 读
# ...