死锁

定义：

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

如下为常见的死锁原因：

a. 互斥条件：

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

b. 请求与保持条件：

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

c. 不剥夺条件：

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

d. 循环等待条件：

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

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

#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_Cstd::lock_guard<std::mutex> lock1(mtx_C);// 保护资源printf("C: operate something\n");// 再获取mtx_Dstd::lock_guard<std::mutex> lock2(mtx_D);
}void D(void)
{// 先获取mtx_Dstd::lock_guard<std::mutex> lock1(mtx_D);// 保护资源printf("D: operate something\n");// 再获取mtx_Cstd::lock_guard<std::mutex> lock2(mtx_C);
}int main()
{// test死锁1——demo1// A();// test死锁2——demo2A1();    // 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！

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