常见的死锁情况分析

死锁

定义：

是指多个进程或线程在执行过程中，由于竞争资源或因通信的需要而产生的相互等待的状态，使得它们无法继续执行下去（单线程中使用不恰当也会导致死锁问题）。

如下为常见的死锁原因：

a. 互斥条件：

至少有一个资源必须处于不可共享的状态，即某个资源在同一时刻只能被一个线程或进程占用。如果其他线程或进程请求该资源，它们必须等待该资源被释放。

b. 请求与保持条件：

一个线程已经持有至少一个资源，但又请求其他线程占有的资源，并且在等待的过程中保持对已占有资源的控制。

c. 不剥夺条件：

已经分配给一个线程的资源，在该线程使用完之前不能被强制剥夺。资源只能由线程自己释放。

d. 循环等待条件：

在一个线程的等待链中，存在一个环路，使得每个线程都在等待另一个线程释放资源。即形成了一种"循环等待"状态。

如下为常见的死锁原因对应代码分析：

cpp 复制代码

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

std::mutex mtxAB;
std::recursive_mutex rmtxAB;
std::mutex mtx_C;
std::mutex mtx_D;

void B(void);
void B1(void);

// 死锁1------demo1
void A(void)
{
    lock_guard<std::mutex> lock(mtxAB);
    // 保护资源
    B();
}

void B(void)
{
    A();
}

// 死锁2------demo2
void A1(void)
{
    // lock_guard<std::mutex> lock(mtxAB);
    // 解决这种死锁方法
    lock_guard<std::recursive_mutex> lock(rmtxAB);
    // 保护资源
    B1();
}

void B1(void)
{
    // lock_guard<std::mutex> lock(mtxAB);
    // 解决这种死锁方法
    lock_guard<std::recursive_mutex> lock(rmtxAB);    
    // 保护资源
}

// 死锁3------demo1
void C(void)
{
    // 先获取mtx_C
    std::lock_guard<std::mutex> lock1(mtx_C);
    // 保护资源
    printf("C: operate something\n");
    // 再获取mtx_D
    std::lock_guard<std::mutex> lock2(mtx_D);
}

void D(void)
{
    // 先获取mtx_D
    std::lock_guard<std::mutex> lock1(mtx_D);
    // 保护资源
    printf("D: operate something\n");
    // 再获取mtx_C
    std::lock_guard<std::mutex> lock2(mtx_C);
}

int main()
{
    // test死锁1------demo1
    // A();
    // test死锁2------demo2
    A1();    
    // test死锁3------demo3
    // std::thread thread[] = {
    //     std::thread(C),
    //     std::thread(D)
    // };
    // for(auto& t : thread){
    //     t.join();
    // }
    // 死锁4...
    printf("the main normally exit!\n");
    return 0;
}

那么如何解决死锁呢？

1. 避免嵌套锁（或锁的顺序）

最常见的避免死锁的方法之一是确保线程按固定的顺序 获取锁。比如，规定所有线程首先获得 MutexA 锁，然后再获得 MutexB 锁，而不允许线程先获得 MutexB 锁再去获得 MutexA 锁。

（可自行尝试解决如上代码中demo3）

2. 使用超时机制

设置锁的超时时间。如果线程在获取锁时超时了，就主动释放已持有的锁，并重新尝试或返回失败，这样就可以避免死锁的发生。

3. 死锁检测与恢复

某些系统会周期性检查是否存在死锁。如果发现死锁状态，可以通过终止一个或多个线程、回滚某些操作或强制释放锁来恢复。

4. 使用递归锁

在一些情况下，如果锁定的资源是递归锁，同一线程可以多次获取锁，而不会导致死锁。这对于某些设计中需要递归调用的情况有效。

end！

各位大佬有什么补充，或者需要更正的欢迎指出哈~