[c++11]多线程编程(四)——死锁(Dead Lock)

死锁

若是你将某个mutex上锁了，却一直不释放，另外一个线程访问该锁保护的资源的时候，就会发生死锁，这种状况下使用lock_guard能够保证析构的时候可以释放锁，然而，当一个操做须要使用两个互斥元的时候，仅仅使用lock_guard并不能保证不会发生死锁，以下面的例子：

#include <iostream>
#include <thread>
#include <string>
#include <mutex>
#include <fstream>
using namespace std;

class LogFile {
    std::mutex _mu;
    std::mutex _mu2;
    ofstream f;
public:
    LogFile() {
        f.open("log.txt");
    }
    ~LogFile() {
        f.close();
    }
    void shared_print(string msg, int id) {
        std::lock_guard<std::mutex> guard(_mu);
        std::lock_guard<std::mutex> guard2(_mu2);
        f << msg << id << endl;
        cout << msg << id << endl;
    }
    void shared_print2(string msg, int id) {
        std::lock_guard<std::mutex> guard(_mu2);
        std::lock_guard<std::mutex> guard2(_mu);
        f << msg << id << endl;
        cout << msg << id << endl;
    }
};

void function_1(LogFile& log) {
    for(int i=0; i>-100; i--)
        log.shared_print2(string("From t1: "), i);
}

int main()
{
    LogFile log;
    std::thread t1(function_1, std::ref(log));

    for(int i=0; i<100; i++)
        log.shared_print(string("From main: "), i);

    t1.join();
    return 0;
}

运行以后，你会发现程序会卡住，这就是发生死锁了。程序运行可能会发生相似下面的状况：

Thread A              Thread B
_mu.lock()             _mu2.lock()
   //死锁               //死锁
_mu2.lock()         _mu.lock()

解决办法有不少：

1. 能够比较mutex的地址，每次都先锁地址小的，如：

   if(&_mu < &_mu2){
       _mu.lock();
       _mu2.unlock();
   }
   else {
       _mu2.lock();
       _mu.lock();
   }

2. 使用层次锁，将互斥锁包装一下，给锁定义一个层次的属性，每次按层次由高到低的顺序上锁。

这两种办法其实都是严格规定上锁顺序，只不过实现方式不一样。

c++标准库中提供了std::lock()函数，可以保证将多个互斥锁同时上锁，

std::lock(_mu, _mu2);

同时，lock_guard也须要作修改，由于互斥锁已经被上锁了，那么lock_guard构造的时候不该该上锁，只是须要在析构的时候释放锁就好了，使用std::adopt_lock表示无需上锁：

std::lock_guard<std::mutex> guard(_mu2, std::adopt_lock);
std::lock_guard<std::mutex> guard2(_mu, std::adopt_lock);

完整代码以下：

#include <iostream>
#include <thread>
#include <string>
#include <mutex>
#include <fstream>
using namespace std;

class LogFile {
    std::mutex _mu;
    std::mutex _mu2;
    ofstream f;
public:
    LogFile() {
        f.open("log.txt");
    }
    ~LogFile() {
        f.close();
    }
    void shared_print(string msg, int id) {
        std::lock(_mu, _mu2);
        std::lock_guard<std::mutex> guard(_mu, std::adopt_lock);
        std::lock_guard<std::mutex> guard2(_mu2, std::adopt_lock);
        f << msg << id << endl;
        cout << msg << id << endl;
    }
    void shared_print2(string msg, int id) {
        std::lock(_mu, _mu2);
        std::lock_guard<std::mutex> guard(_mu2, std::adopt_lock);
        std::lock_guard<std::mutex> guard2(_mu, std::adopt_lock);
        f << msg << id << endl;
        cout << msg << id << endl;
    }
};

void function_1(LogFile& log) {
    for(int i=0; i>-100; i--)
        log.shared_print2(string("From t1: "), i);
}

int main()
{
    LogFile log;
    std::thread t1(function_1, std::ref(log));

    for(int i=0; i<100; i++)
        log.shared_print(string("From main: "), i);

    t1.join();
    return 0;
}

总结一下，对于避免死锁，有如下几点建议：

1. 建议尽可能同时只对一个互斥锁上锁。

   {
       std::lock_guard<std::mutex> guard(_mu2);
       //do something
       f << msg << id << endl;
   }
   {
       std::lock_guard<std::mutex> guard2(_mu);
       cout << msg << id << endl;
   }

2. 不要在互斥锁保护的区域使用用户自定义的代码，由于用户的代码可能操做了其余的互斥锁。

   {
       std::lock_guard<std::mutex> guard(_mu2);
       user_function(); // never do this!!!
       f << msg << id << endl;
   }

3. 若是想同时对多个互斥锁上锁，要使用std::lock()。
4. 给锁定义顺序（使用层次锁，或者比较地址等），每次以一样的顺序进行上锁。详细介绍可看C++并发编程实战。

参考

1. C++并发编程实战
2. C++ Threading #4: Deadlock