CentOS中C++并发编程怎样避免死锁

在CentOS中进行C++并发编程时，避免死锁是一个重要的问题。以下是一些避免死锁的策略：

1. 避免嵌套锁

尽量避免在一个锁的保护范围内获取另一个锁。如果必须这样做，确保以相同的顺序获取所有锁。

std::lock(mutex1, mutex2);
std::lock_guard<std::mutex> lock1(mutex1, std::adopt_lock);
std::lock_guard<std::mutex> lock2(mutex2, std::adopt_lock);

2. 使用std::lock

使用std::lock函数来同时锁定多个互斥量，这样可以避免死锁。

std::mutex mutex1, mutex2;
// ...
std::lock(mutex1, mutex2);
std::lock_guard<std::mutex> lock1(mutex1, std::adopt_lock);
std::lock_guard<std::mutex> lock2(mutex2, std::adopt_lock);

3. 使用std::unique_lock和std::defer_lock

使用std::unique_lock和std::defer_lock来延迟锁的获取，这样可以更灵活地控制锁的顺序。

std::mutex mutex1, mutex2;
// ...
std::unique_lock<std::mutex> lock1(mutex1, std::defer_lock);
std::unique_lock<std::mutex> lock2(mutex2, std::defer_lock);
std::lock(lock1, lock2);

4. 使用std::scoped_lock

C++17引入了std::scoped_lock，它可以一次性锁定多个互斥量，并且保证锁定的顺序。

std::mutex mutex1, mutex2;
// ...
std::scoped_lock lock(mutex1, mutex2);

5. 避免长时间持有锁

尽量减少持有锁的时间，只在必要时才持有锁，并尽快释放锁。

6. 使用条件变量

使用条件变量来同步线程，而不是通过轮询或忙等待。

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void worker_thread() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{ return ready; });
    // 执行任务
}

void trigger_work() {
    std::lock_guard<std::mutex> lock(mtx);
    ready = true;
    cv.notify_all();
}

7. 死锁检测和恢复

虽然这不是预防性的措施，但可以在系统中实现死锁检测和恢复机制。例如，使用定时器来检测长时间未释放的锁，并采取相应的恢复措施。

8. 使用RAII（Resource Acquisition Is Initialization）

确保资源获取即初始化（RAII）原则，使用std::lock_guard或std::unique_lock来自动管理锁的生命周期。

示例代码

以下是一个简单的示例，展示了如何使用std::scoped_lock来避免死锁：

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

std::mutex mtx1, mtx2;

void thread1() {
    std::scoped_lock lock(mtx1, mtx2);
    std::cout << "Thread 1 acquired both locks\n";
}

void thread2() {
    std::scoped_lock lock(mtx1, mtx2);
    std::cout << "Thread 2 acquired both locks\n";
}

int main() {
    std::thread t1(thread1);
    std::thread t2(thread2);

    t1.join();
    t2.join();

    return 0;
}

通过遵循这些策略，可以大大减少在CentOS中进行C++并发编程时发生死锁的风险。