C++之死锁

背景

在多线程编程中，死锁是一个常见的问题，它会导致程序陷入无法继续执行的状态。在这篇博客中，我们将介绍C++中死锁的概念、产生原因以及解决办法。

什么是死锁？

死锁是指多个线程在等待对方释放资源，导致彼此都无法继续执行的情况。死锁通常发生在多个线程同时锁定多个互斥锁的情况下。以下是一个简单的死锁示例：

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

std::mutex mtx1;
std::mutex mtx2;

void thread1() {
    std::unique_lock<std::mutex> lock1(mtx1);
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    std::unique_lock<std::mutex> lock2(mtx2);
    std::cout << "Thread 1 finished." << std::endl;
}

void thread2() {
    std::unique_lock<std::mutex> lock2(mtx2);
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    std::unique_lock<std::mutex> lock1(mtx1);
    std::cout << "Thread 2 finished." << std::endl;
}

int main() {
    std::thread t1(thread1);
    std::thread t2(thread2);
    t1.join();
    t2.join();
    return 0;
}

在这个例子中，thread1函数先锁定mtx1，然后尝试锁定mtx2；thread2函数先锁定mtx2，然后尝试锁定mtx1。由于两个线程都在等待对方释放互斥锁，导致死锁发生。

死锁的四个必要条件

死锁发生需要满足以下四个必要条件：

• 互斥条件：一个资源在某一时刻只能被一个线程占用。
• 请求与保持条件：一个线程在请求其他资源时，保持对已分配资源的占用。
• 不可抢占条件：一个资源只能被占用的线程主动释放，其他线程不能强行抢占。
• 循环等待条件：存在一个线程等待资源的循环链，链中的每个线程都在等待下一个线程占用的资源。 只有在这四个条件同时满足时，死锁才会发生。因此，要解决死锁问题，我们需要破坏这四个条件中的至少一个。

解决死锁的方法

按照固定的顺序加锁

确保所有线程在加锁时遵循相同的顺序，这样可以避免循环等待导致的死锁。例如，在上述死锁示例中，我们可以修改thread2函数，使其先锁定mtx1，然后锁定mtx2。

使用std::lock()一次性加锁多个互斥锁

std::lock()函数可以保证在没有死锁的情况下一次性锁定多个互斥锁。例如，当我们需要锁定两个互斥锁mtx1和mtx2时，我们可以使用以下代码：

std::lock(mtx1, mtx2);

使用std::try_lock()尝试加锁

std::try_lock()函数尝试加锁，如果加锁失败，则立即返回。这样我们可以在加锁失败时执行其他操作，避免死锁。例如，我们可以修改上述死锁示例中的thread1和thread2函数，使用std::try_lock()尝试加锁：

void thread1() {
    while (true) {
        if (mtx1.try_lock()) {
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
            if (mtx2.try_lock()) {
                std::cout << "Thread 1 finished." << std::endl;
                mtx2.unlock();
                mtx1.unlock();
                break;
            }
            mtx1.unlock();
        }
    }
}

void thread2() {
    while (true) {
        if (mtx2.try_lock()) {
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
            if (mtx1.try_lock()) {
                std::cout << "Thread 2 finished." << std::endl;
                mtx1.unlock();
                mtx2.unlock();
                break;
            }
            mtx2.unlock();
        }
    }
}

在这个修改后的例子中，thread1和thread2函数使用std::try_lock()尝试加锁。如果加锁失败，它们会立即释放已经占用的互斥锁，然后继续尝试加锁。这样可以避免死锁问题。

避免嵌套锁

尽量避免在已经锁定一个互斥锁的情况下再锁定其他互斥锁。如果必须使用嵌套锁，可以考虑将不同的操作分离到不同的函数中，并在函数调用之间解锁互斥锁。

使用锁的分层

为互斥锁分配层次，并确保在较低层次的互斥锁解锁后才能锁定较高层次的互斥锁。这样可以减少死锁发生的可能性。

最后

总结一下，在这篇博客中，我们介绍了C++中死锁的概念、产生原因以及解决办法。通过遵循一定的准则和技巧，我们可以有效地避免死锁问题，确保多线程程序的正确性和稳定性。在进行多线程编程时，我们需要时刻关注死锁等潜在风险，并采取相应的措施来防范和解决这些问题。