当前位置：首页 > news >正文

常见的死锁情况分析

news 来源：原创 2025/5/2 17:44:49

死锁

定义：

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

如下为常见的死锁原因：

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_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;
}

那么如何解决死锁呢？