std::get<C++11多线程库~线程间共享数据>(10)：使用互斥量保护共享数据（4）

#ifndef DEADLOCK_QUESTIONDESCRIBLE_AND_SOLUTION_H
#define DEADLOCK_QUESTIONDESCRIBLE_AND_SOLUTION_H

/*
 * 话题1：使用互斥量保护共享数据
 *
 * 接下来学习第四个小话题：死锁，死锁的问题描述，死锁的解决方案
 *
 *      互斥量在解决共享数据安全的同时，除了会引入条件竞争， 还可能会引发死锁。
 *      条件竞争使得共享数据变得不安全，而死锁会导致各线程僵持，导致线程间出现互相等待的尴尬局面。
 *
 *      下面我们就来学习一下， 出现死锁的场景，以及如何避免死锁的发生。
 *
*/

/*
 * 死锁的问题描述：
 *
 *      线程内出现两个或两个以上的互斥量时， 比如互斥量ma和mb, 有两个线程TA和TB, 线程TA先锁住了ma，准备继续对mb上锁， 而正在此时，
 * 线程TB锁住了mb,准备继续对ma上锁。 线程TA等待着线程TB释放互斥量mb，线程TB等待线程TA释放互斥量ma， 谁也不让谁，谁也不罢休，两个线程
 * 僵持等待。这就是死锁发生的情况。
*/


/*
 * 死锁的解决方案：
 *
 *      一般的建议：让多个互斥量总是以相同的顺序上锁。互斥量mb总是在ma上锁之后上锁。可以将这个建议套入上面对死锁问题的描述，你就能够领悟了。
 *
 *      一般的建议往往只能搞定一般的问题， 如果多个互斥量所属于同一个作用域内，那么这个一般的建议是可以搞定的。那么多个互斥量时，如何能保证
 * 不出问题，一定不会出现死锁呢？
 *
 *      C++ 标准库提供了 std::lock， 可以一次性的锁住多个（两个及两个以上）互斥量，并且没有副作用（没有死锁风险）。std::lock的原则是，
 * 要么对所有互斥量都成功上锁，要么一个互斥量也不上锁。
*/

#include <mutex>
struct Data{

};
void swap(Data & ldata, Data &rdata);
bool greater(Data &ldata, Data & rdata);

class DeadLock_QuestionDescrible_and_Solution;
void swap(DeadLock_QuestionDescrible_and_Solution &lobj, DeadLock_QuestionDescrible_and_Solution & robj);
bool greater(DeadLock_QuestionDescrible_and_Solution &lobj, DeadLock_QuestionDescrible_and_Solution & robj);

class DeadLock_QuestionDescrible_and_Solution
{
    Data m_data;
    std::mutex m_mutex;
public:
    DeadLock_QuestionDescrible_and_Solution(Data data):m_data(data){

    }

    friend void swap(DeadLock_QuestionDescrible_and_Solution &lobj, DeadLock_QuestionDescrible_and_Solution & robj)
    {
        if (&lobj == &robj){
            return ;
        }
        else{
            std::lock(lobj.m_mutex, robj.m_mutex);
            std::lock_guard<std::mutex> l_guard(lobj.m_mutex, std::adopt_lock);
            std::lock_guard<std::mutex> r_guard(robj.m_mutex, std::adopt_lock);
            swap(lobj.m_data, robj.m_data);
        }
    }

    friend bool greater(DeadLock_QuestionDescrible_and_Solution &lobj, DeadLock_QuestionDescrible_and_Solution & robj)
    {
        if (&lobj == &robj){
            return false;
        }
        else{
            std::lock(lobj.m_mutex, robj.m_mutex);
            std::lock_guard<std::mutex> l_guard(lobj.m_mutex, std::adopt_lock);
            std::lock_guard<std::mutex> r_guard(robj.m_mutex, std::adopt_lock);
            return greater(lobj.m_data, robj.m_data);
        }
    }
};

/*
 *      上边这个例子很好的阐明了， "一般的建议只能搞定一般的问题"。
 * 上边例子中 DeadLock_QuestionDescrible_and_Solution::swap 和 DeadLock_QuestionDescrible_and_Solution::greater 两个函数
 * 很好的说明了问题。
 *
 *      我们来分析一下， 每一个 Data 实例都有一个互斥量保护， 在 swap 和 greater 函数中，就都出现了 两个实例和两个互斥量。
 *
 *      咋一看，如果调用 swap 和 greater 函数时，参数按相同的顺序传递，似乎也不会出现死锁， 但实际上，我们把接口提供给用户，用户是很难保证
 * 多个参数按相同顺序调用我们提供的接口。
 *
 *      比如， 线程TA 调用 swap() 函数，按序传递 objA objB；线程TB 调用 greater()函数，按序传递 ojbB objA。 死锁就诞生了！
 *
 *      对于，一般建议提到的做法，按序对互斥量上锁， 下边给出一个例子。
 *
*/

struct OtherData{

};

class OtherObject_ThreadSafe{
    Data m_data;
    std::mutex m_data_mutex;

    OtherData m_otherData;
    std::mutex m_otherData_mutex;

    void func1(){
        std::lock_guard<std::mutex> guard_data(m_data_mutex);
        std::lock_guard<std::mutex> guard_otherData(m_otherData_mutex);

        //m_data and m_otherData do something...
    }

    void func2(){
        std::lock_guard<std::mutex> guard_data(m_data_mutex);
        std::lock_guard<std::mutex> guard_otherData(m_otherData_mutex);

        //m_data and m_otherData do something...
    }
};

/*
 * 上边例子演示了，同一作用域内，需要对多个互斥量上锁，可以采用一般的建议，按相同的顺序对互斥量进行上锁，就可以搞定即保护了共享数据，又不会出现死锁。
 *
 *
 * 友情提醒： 实际编程中，能要底层级别手段搞定的问题，就尽量不要用高级的东西，毕竟越高级代价也就越高！！！
*/


/*
 * 拓展：
 * C++17 对组合使用 std::lock()函数 和 std::lock_guard 模板类 提供了另一个支持，那便是： std::scoped_lock模板类
 *
 * 因此， 上边的 swap() 函数可以改写成如下形式。
*/

friend void swap(DeadLock_QuestionDescrible_and_Solution &lobj, DeadLock_QuestionDescrible_and_Solution & robj)
{
    if (&lobj == &robj){
        return ;
    }
    else{
        std::scoped_lock sl(lobj.m_mutex, robj.m_mutex);
        swap(lobj.m_data, robj.m_data);
    }
}

/*
 *      std::scoped_lock<>一种新的RAII类型模板类型，与std::lock_guard<>的功能等价，
 * 这个新类型能接受不定数量的互斥量类型作为模板参数，以及相应的互斥量(数量和类型)作为构造参数。
 * 互斥量支持构造即上锁，与std::lock的用法相同，其解锁阶段是在析构中进行。
*/
#endif // DEADLOCK_QUESTIONDESCRIBLE_AND_SOLUTION_H