C++-死锁

死锁

当一个操作需要两个及以上的互斥锁，就可能发生死锁。多个线程分别已经获取到其中一个互斥锁，而它们又在互相等待其他线程释放对方的互斥锁，从而导致死锁。注意，当线程相互等待时，也会造成“死锁”，即使两个线程内都没有“锁”。

避免死锁

通常情况下，避免死锁的建议之一是将多个互斥锁总是以相同的顺序锁住。例如有两个互斥锁A和B，我们总是保证先获取互斥锁A再获取互斥锁B。
但在某些情况下，要保证这一点会很困难，例如每个对象内都有一个互斥锁。考虑有一个类包含一个互斥锁成员，一个交换数据的方法swap，现在有两个该类的对象X、Y，当我们调用swap交换X、Y的数据时，swap内部总是先获取第一个参数对象的互斥锁，然后获取第二个参数对象的互斥锁。现在，如果有两个线程都试图调用swap交换X、Y的数据，但是一个线程调用swap(X,Y)，另一个调用swap(Y,X)，这样就会造成死锁。

还好，C++标准库有提供了一个函数std::lock，它可以一次性锁住多个互斥锁，并且要么在这些互斥锁全部获取成功，要么全部失败，从而避免上述死锁情形发生。

class some_big_object;
void swap(some_big_object &lhs, some_big_object &rhs);
class X
{
private:
    some_big_object some_detail;
    std::mutex m;

public:
    X(some_big_object const &sd) : some_detail(sd) {}
    friend void swap(X &lhs, X &rhs)
    {
        if (&lhs == &rhs)
            return;
        std::lock(lhs.m, rhs.m);
        std::lock_guard<std::mutex> lock_a(lhs.m, std::adopt_lock);
        std::lock_guard<std::mutex> lock_b(rhs.m, std::adopt_lock);
        swap(lhs.some_detail, rhs.some_detail);
    }
};

&lhs == &rhs检查避免了一个锁被lock两次，那将导致未定义的行为。std::lock一次性获取两个互斥锁，lock_guard默认会在构造函数内锁住互斥锁，std::adopt_lock表明此时互斥锁已经锁住，构造函数将不会再获取这个互斥锁。lock_guard保证了即使发生了异常也能正常释放互斥锁。对于std::lock调用，如果一个锁成功获取后，另一个锁获取失败，将抛出一个异常，并且已经获取成功的锁将释放。

c++17提供了一个可变参数模板std::scoped_lock<>，相当于是std::lock和std::lock_guard的结合，他在构造函数内获取所有锁，析构函数内释放所有锁，并且保证锁要么全部获取或要么全部不获取。

void swap(X& lhs, X& rhs)
{
    if(&lhs==&rhs)
        return;
    //c++17自动类模板参数推导
    //等价于std::scoped_lock<std::mutex,std::mutex> guard(lhs.m,rhs.m);
    std::scoped_lock guard(lhs.m,rhs.m);
    swap(lhs.some_detail,rhs.some_detail);
}

避免死锁的几个原则

尽管std::lock能保证在同时获取多个锁的情况下不发生死锁，但是如果多个锁必须分别获取，那就只能依靠一些原则来避免死锁。这些原则的思想归成一句话就是：不要等待一个“可能等待当前线程的线程”。

• 避免嵌套锁
  即如果你已经有了一个锁，则不要再请求其他锁（即嵌套），如果要获取多个锁，请使用std::lock
• 拥有锁的情况下避免执行用户代码
  因为用户可能请求锁，如果用户请求的锁就是当前拥有的锁，那么就会造成死锁
• 将多个锁总是按照固定顺序获取
• 使用带层级的锁
  即给每个锁一个"层级"，如500，700，1000，当已经拥有层级高的锁，就不能获取同级或者层级更低的锁，否则抛出一个异常。因为层级锁本质上也是规定了获取锁的顺序，因此能避免死锁。