死锁Deadlock

定义

        死锁是指两个或多个线程互相持有对方所需的资源，从而导致它们无法继续执行的情况。如下图所示，现有两个线程，分别是线程A及线程B，线程A持有锁A，线程B持有锁B。此时线程A想获取锁B，但锁B需等到线程B的结束才能解锁；而线程B想获取锁A，但锁A需等到线程A的结束才能解锁，这样就造成了线程A等线程B，线程B等线程A，从而出现死锁。

图解两线程死锁现象

c++死锁示例 

#include 
#include 
#include 

std::mutex mutexA;
std::mutex mutexB;

void ThreadA()
{
    std::unique_lock lockA(mutexA);
    std::this_thread::sleep_for(std::chrono::milliseconds(100));  // 为了增加发生死锁的概率，让线程A先获取锁A再休眠一段时间
    std::cout << "Thread A acquired mutex A" << std::endl;

    std::unique_lock lockB(mutexB);
    std::cout << "Thread A acquired mutex B" << std::endl;

    // 执行操作...

    lockB.unlock();
    lockA.unlock();
}

void ThreadB()
{
    std::unique_lock lockB(mutexB);
    std::cout << "Thread B acquired mutex B" << std::endl;

    std::unique_lock lockA(mutexA);
    std::cout << "Thread B acquired mutex A" << std::endl;

    // 执行操作...

    lockA.unlock();
    lockB.unlock();
}

int main()
{
    std::thread threadA(ThreadA);
    std::thread threadB(ThreadB);

    threadA.join();
    threadB.join();

    return 0;
}

输出结果：（程序中止崩溃）

分析： 

        在上述代码中，有两个线程（ThreadA和ThreadB），它们都试图以不同的顺序获取两个互斥锁（mutexA和mutexB）。如果ThreadA先获取了mutexA，然后尝试获取mutexB，而ThreadB先获取了mutexB，然后尝试获取mutexA，那么就会发生死锁。

        当ThreadA获取了mutexA后，它会休眠一段时间。在此期间，ThreadB获取了mutexB。接着，ThreadA试图获取mutexB时会被阻塞，因为ThreadB持有mutexB。同时，ThreadB也试图获取mutexA时会被阻塞，因为ThreadA持有mutexA。这样，两个线程都无法继续执行，导致程序陷入死锁状态。

        需要注意的是，死锁不一定会在每次运行时都发生，它取决于线程的调度和执行顺序。如果在实际应用中遇到死锁问题，可以通过合理的锁顺序、避免嵌套锁、使用死锁检测等方法来预防和解决死锁。

c++解决死锁

修改上述代码，使用std::lock函数来避免死锁：

#include 
#include 
#include 

std::mutex mutexA;
std::mutex mutexB;

void ThreadA()
{
    std::unique_lock lockA(mutexA, std::defer_lock);
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    std::cout << "Thread A acquired mutex A" << std::endl;

    std::unique_lock lockB(mutexB, std::defer_lock);
    std::cout << "Thread A acquired mutex B" << std::endl;

    std::lock(lockA, lockB);  // 使用std::lock同时获取两个锁

    // 执行操作...

    lockB.unlock();
    lockA.unlock();
}

void ThreadB()
{
    std::unique_lock lockB(mutexB, std::defer_lock);
    std::cout << "Thread B acquired mutex B" << std::endl;

    std::unique_lock lockA(mutexA, std::defer_lock);
    std::cout << "Thread B acquired mutex A" << std::endl;

    std::lock(lockA, lockB);  // 使用std::lock同时获取两个锁

    // 执行操作...

    lockA.unlock();
    lockB.unlock();
}

int main()
{
    std::thread threadA(ThreadA);
    std::thread threadB(ThreadB);

    threadA.join();
    threadB.join();

    return 0;
}

输出结果：（正确结果）

分析：

        在修改后的代码中，使用std::defer_lock参数来延迟锁的获取，而不是在构造std::unique_lock对象时立即获取锁。然后，在需要同时获取两个锁的地方，使用std::lock函数来获取锁，这样可以避免死锁发生。

        需要注意的是，虽然上述方法可以解决死锁问题，但在实际编程中，应尽量避免复杂的锁依赖关系和嵌套锁的使用，以减少死锁的可能性。

产生死锁的原因

竞争不可抢占资源（互斥资源）
线程推进顺序不当

产生死锁的四个必要条件

1. 互斥条件（Mutual Exclusion）：至少有一个资源同时只能被一个进程或线程占用，即在一段时间内只能有一个进程或线程访问该资源。

2. 请求与保持条件（Hold and Wait）：进程或线程在持有至少一个资源的同时，又请求其他进程或线程所持有的资源。

3. 不可剥夺条件（No Preemption）：已经分配给一个进程或线程的资源不能被强制性地剥夺，只能由持有资源的进程或线程显式地释放。

4. 循环等待条件（Circular Wait）：存在一个进程或线程的资源请求序列，使得每个进程或线程都在等待下一个进程或线程所持有的资源。

当这四个条件同时满足时，就可能发生死锁。

例如，考虑以下场景：

• 进程A持有资源X，并请求资源Y。
• 进程B持有资源Y，并请求资源X。

        如果进程A和进程B同时运行，并且它们按照上述顺序获取和释放资源，那么就会出现死锁。进程A持有资源X，进程B持有资源Y，但它们互相需要对方持有的资源才能继续执行，导致两个进程都无法继续执行下去。

处理死锁的方法

（1）预防死锁（破坏四条件）

1. 破坏互斥条件：例如，对于某些资源，引入共享访问的机制，使得多个进程或线程可以同时访问资源。

2. 破坏请求与保持条件：要求进程在请求资源之前释放已经持有的资源，或者一次性请求所有需要的资源。

3. 破坏不可剥夺条件：引入资源预约和强制剥夺机制，以确保资源可以被其他进程或线程使用。

4. 破坏循环等待条件：通过定义资源的线性顺序，要求进程按照相同的顺序请求资源，从而避免循环等待。

（2）避免死锁（银行家算法）