C++ 多线程同步实战：互斥锁与死锁规避

加上锁之后，无论怎么运行，count 的值都会稳定在 200000。临界区的概念由此体现：同一时刻只有一个线程能进入这段代码。

死锁的产生与规避

在使用互斥锁时，除了数据竞争，另一个常见的大坑是死锁。简单来说，就是多个线程互相持有对方需要的锁，导致谁都无法继续执行。

死锁通常需要满足四个条件：互斥、请求与保持、不可剥夺、循环等待。一个经典的死锁示例是两个线程分别持有锁 A 和锁 B，却试图获取对方的锁：

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

using namespace std;

mutex mtx1, mtx2;

void thread1() {
    mtx1.lock();
    this_thread::sleep_for(chrono::milliseconds(100));
    mtx2.lock(); // 等待 mtx2，此时 thread2 持有 mtx2 并等待 mtx1
    cout << "thread1 执行完毕" << endl;
    mtx2.unlock();
    mtx1.unlock();
}

void thread2() {
    mtx2.lock();
    this_thread::sleep_for(chrono::milliseconds(100));
    mtx1.lock(); // 等待 mtx1，此时 thread1 持有 mtx1 并等待 mtx2
    cout << "thread2 执行完毕" << endl;
    mtx1.unlock();
    mtx2.unlock();
}

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

运行这段代码，程序会卡住不动。避免死锁有几种常用策略：

1. 固定锁的获取顺序：所有线程都按相同顺序申请锁。
2. 使用 std::lock：一次性获取多个锁，内部处理了死锁检测。
3. 设置超时：使用 try_lock 或带超时的锁，防止永久阻塞。

实战案例：多线程售票系统

为了巩固理解，我们模拟一个简单的售票系统。多个窗口同时卖票，必须保证票数不会变成负数，也不会重复卖出。

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

using namespace std;

int tickets = 100; // 总票数
mutex mtx;         // 售票锁

void sell_tickets(int window_id) {
    while (true) {
        lock_guard<mutex> lock(mtx);
        if (tickets > 0) {
            cout << "窗口" << window_id << "售出第" << tickets << "张票" << endl;
            tickets--;
            this_thread::sleep_for(chrono::milliseconds(50)); // 模拟耗时
        } else {
            break;
        }
    }
    cout << "窗口" << window_id << "售票结束" << endl;
}

int main() {
    vector<thread> windows;
    // 创建 5 个售票窗口
    for (int i = 1; i <= 5; ++i) {
        windows.emplace_back(sell_tickets, i);
    }
    // 等待所有窗口售票结束
    for (auto& t : windows) {
        t.join();
    }
    cout << "所有票已售罄" << endl;
    return 0;
}

在这个案例中，互斥锁确保了 tickets 的检查和递减操作是原子的。最终你会看到 5 个窗口有序地卖完 100 张票，没有任何逻辑错误。

总结

多线程编程的核心在于平衡性能与安全。std::mutex 配合 std::lock_guard 是处理共享资源的标准方案。记住，锁不是越多越好，而是越精准越好。同时，时刻警惕死锁风险，遵循一致的锁获取顺序，能让你的并发代码更加健壮。