C++多线程中的互斥锁：用法与死锁规避

实际写代码的时候，我几乎不会手动去调 lock 和 unlock，直接让 lock_guard 管理，省心而且更安全。

用锁保护临界区

把上面的例子加个锁：

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

using namespace std;

int count = 0;
mutex mtx;

void increment() {
    for (int i = 0; i < 100000; ++i) {
        lock_guard<mutex> lock(mtx);
        count++;
    }
}

int main() {
    thread t1(increment);
    thread t2(increment);
    t1.join();
    t2.join();
    cout << "最终 count 值：" << count << endl;
    return 0;
}

这次每次都会稳定输出 200000。lock_guard 把 count++ 这块临界区包了起来，同一时间只有一个线程能进去。

这里有两个概念其实是一件事的两面：

• 临界区：必须串行执行的代码段，像这里的 count++。
• 互斥锁的作用：保证临界区的互斥访问。

死锁是怎么发生的

死锁就是多个线程互相掐着对方想要的锁不松手，谁都动不了。要形成死锁，四个条件缺一不可：

1. 资源互斥：同一时刻锁只能被一个线程持有。
2. 持有并等待：线程拿着一个锁的同时还在等别的锁。
3. 不可剥夺：别人不能强行抢走线程手里的锁。
4. 循环等待：A 等 B 的锁，B 等 A 的锁。

下面这个例子特意构造了最后一种条件：

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

using namespace std;

mutex mtx1, mtx2;

void thread1() {
    mtx1.lock();
    this_thread::sleep_for(chrono::milliseconds(100));
    mtx2.lock();
    cout << "thread1 执行完毕" << endl;
    mtx2.unlock();
    mtx1.unlock();
}

void thread2() {
    mtx2.lock();
    this_thread::sleep_for(chrono::milliseconds(100));
    mtx1.lock();
    cout << "thread2 执行完毕" << endl;
    mtx1.unlock();
    mtx2.unlock();
}

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

跑起来两个线程会卡死，控制台什么也不输出。它们互相等对方的锁，典型的'你不放我也不放'。

避免死锁的常用手段

1. 统一加锁顺序：如果所有线程都按 mtx1 → mtx2 的顺序拿，就不会出现交叉等待。这是最朴素也最可靠的办法，缺点是要在全局范围内约束顺序，代码规模大了容易忘记。
2. 使用 std::lock 一次锁多个：std::lock(mtx1, mtx2) 会用一个避免死锁的算法同时获取两个锁，要么都拿到，要么都没拿。然后再用 lock_guard 配合 std::adopt_lock 把所有权接过来。
3. 带超时的尝试锁：用 try_lock() 或 std::timed_mutex 定个超时，拿不到就放弃，这样可以打破等待环路，但需要处理好放弃后的回退逻辑。

实际项目中，死锁往往比示例更隐蔽——锁可能分散在不同的函数甚至不同的模块里。养成良好的加锁习惯，比如尽量不在持有锁时调用外部函数，能显著降低踩坑概率。

一个简单的售票模拟

用多线程模拟几个窗口一起卖票，互斥锁保证不会把同一张票卖给两个人，也不会卖出负数。

#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;
    for (int i = 1; i <= 5; ++i) {
        windows.emplace_back(sell_tickets, i);
    }
    for (auto& t : windows) {
        t.join();
    }
    cout << "所有票已售罄" << endl;
    return 0;
}

运行结果从 100 开始倒着卖，5 个窗口交替输出，最终全部卖完，票数归零。

总结

多线程访问共享资源得加锁，否则数据竞争会让结果不可预期。std::mutex 是最基础的互斥锁，配合 lock_guard 能安全地管理锁的生命周期。死锁有四个必要条件，打破任一条件就能避免，日常最实用的是统一加锁顺序和用 std::lock 批量锁。互斥锁保护的是临界区，临界区越小、越明确，性能越好，出错的概率也越低。