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

快速网站建设多少钱设计公司取名字大全集

news 2025/7/7 20:10:05

快速网站建设多少钱,设计公司取名字大全集,企业网站开发论文,遵义网站建设制作公司定义死锁是指两个或多个线程互相持有对方所需的资源，从而导致它们无法继续执行的情况。如下图所示，现有两个线程，分别是线程A及线程B，线程A持有锁A，线程B持有锁B。此时线程A想获取锁B，但锁B需等到线程B的结…

定义

死锁是指两个或多个线程互相持有对方所需的资源，从而导致它们无法继续执行的情况。如下图所示，现有两个线程，分别是线程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;
}

输出结果：（正确结果）