避免死锁的一些注意事项

1. 避免嵌套锁， 如果每个线程都只占有一个锁， 则可以很大程度上避免死锁。
其死锁的情况是， 线程 1 依次获得 A 对象和 B 对象的锁， 然后决定等另一个线程的信号再继续， 从而先释放了 B 对象的的锁。
可是线程 2 需要同时拥有对象 A 和对象 B 的锁才能向线程 1 发信号。
从而导致， 线程 2 因无法获得对象 A 上的锁， 因而阻塞， 等待线程 1 释放对象 A 上的锁。 而同时线程 1 也一直阻塞， 等待线程 2 的信号， 因此不会释放对象 A 的锁。

2. 用固定的顺序获取锁
如果非要同时拥有多个锁， 同时无法拥有单个的锁， 那么最好的处理方式是以固定的顺序得到他们。典型的情况是在一个链表的结构中， 如果要取得节点 B 的锁， 那么需要先取得节点 A 的锁， 接着取得节点 C 的锁。

3. 设置优先级
当多个锁存在时， 设立优先级是个好主意，这样可以避免低优先级的 mutex 会先于高优先级的拥有锁。例如以下代码：

hierarchical_mutex high_level_mutex(10000);
hierarchical_mutex  low_level_mutex(5000);

int do_low_level_stuff();

int low_level_func()
{
    lock_guard<hierarchical_mutex> lk(low_level_mutex);
    return do_low_level_stuff();
}

void high_level_stuff(int some_param);

void high_level_func()
{
    lock_guard<hierarchical_mutex> lk(high_level_mutex);
    high_level_stuff(low_level_func);
}

void thread_a()
{
    high_level_func();
}

hierarchical_mutex other_mutex(100);
void do_other_stuff();

void other_stuff()
{
    high_levek_func();
    do_other_stuff();
}

void thread_b()
{
    lock_guard<hierarchical_mutex> lk(other_mutex);
    other_stuff();
}

其中， thread_a 就会成功， 而 therad_b 就会运行出错。
为啥呢？
因为它首先会拥有 other_mutex 的锁，other_mutex 的优先级只有 100， 却在  high_level_mutex 前得到锁， 这违反了优先级， 所以 hierarchical_mutex 会报错并抛出一个异常， 然后退出程序。
上文中提到的 hierarchical_mutex 并不是标准库的一部分， 但是可以很容易的实现：

class hierarchical_mutex
{
    mutex                                   internal_mutex;
    unsigned long const                     hierarchy_value;
    unsigned                                previous_hierarchy_value;
    static  thread_local unsigned long 　　 this_thread_hierarchy_value;

    // second mutex must now be less than
    //that of the mutex already held 　　//in order for the check to pass
    void check_for_hierarcy_violation()
    {
        if(this_thread_hierarchy_value <= hierarchy_value){
            throw std::logic_error("mutex hierarchical violated");
        }
    }

    void update_hierarchy_value()
    {
        previous_hierarchy_value     = this_thread_hierarchy_value;
        this_thread_hierarchy_value = hierarchy_value;
    }
public:
        explicit hierarchical_mutex(unsigned long value)
            : hierarchy_value(value),
              previous_hierarchy_value(0)
        {}

        void lock()
        {
            check_for_hierarcy_violation();
            internal_mutex.lock();
            update_hierarchy_value();
        }

        void unlock()
        {
            this_thread_hierarchy_value = previous_hierarchy_value;
            internal_mutex.unlock();
        }

        bool try_lock()
        {
            check_for_hierarcy_violation();
            if(!internal_mutex.try_lock()){
                return false;
            }

            update_hierarchy_value();
            return true;
        }
};

// initialized to the maximum value,
// so initially any mutex can be locked
thread_local unsigned long
    hierarchical_mutex::this_thread_hierarchy_value(ULONG_MAX);