死锁Deadlock

定义

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

c++死锁示例

#include <iostream>
#include <thread>
#include <mutex>

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

void ThreadA()
{
    std::unique_lock<std::mutex> 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<std::mutex> lockB(mutexB);
    std::cout << "Thread A acquired mutex B" << std::endl;

    // 执行操作...

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

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

    std::unique_lock<std::mutex> 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 <iostream>
#include <thread>
#include <mutex>

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

void ThreadA()
{
    std::unique_lock<std::mutex> 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<std::mutex> 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<std::mutex> lockB(mutexB, std::defer_lock);
    std::cout << "Thread B acquired mutex B" << std::endl;

    std::unique_lock<std::mutex> 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;
}

输出结果：（正确结果）