C++多线程同步之互斥锁(mutex)实战指南

多线程编程的魅力在于并发带来的性能提升，但随之而来的共享资源访问问题，却让不少开发者头疼。今天，我们就来深入聊聊C++中解决这类问题的基石工具——互斥锁。通过掌握它，你不仅能写出线程安全的代码，更能理解同步机制背后的设计哲学。

48.1 多线程同步的必要性

想象一下，多个线程同时操作同一个银&行账户余额，会发生什么？如果没有协调机制，结果很可能是一团糟。这就是多线程编程中的核心挑战：资源竞争。当多个线程不加控制地读写同一块内存或变量时，就会产生所谓的线程安全问题，导致程序行为变得不可预测。

来看一个经典例子：两个线程同时对全局变量count进行十万次自增。

#include 
#include 
using namespace std;
int count = 0;
void increment() {
    for (int i = 0; i < 100000; ++i) {
        count++; // 非原子操作，存在数据竞争
    }
}
int main() {
    thread t1(increment);
    thread t2(increment);
    t1.join();
    t2.join();
    cout << "最终 count 值：" << count << endl;
    return 0;
}

运行几次你会发现，最终结果往往不是预期的20万，而是一个小于它的随机数。原因在于count++这个看似简单的操作，在底层可能对应着“读取-修改-写入”多个步骤，线程的交替执行会打乱这个流程。要解决这个问题，就必须引入线程同步机制，而互斥锁正是其中最直接、最常用的一种。

48.2 C++ 标准库中的互斥锁

自C++11起，标准库在头文件中提供了一套完整的互斥锁工具。其中，std::mutex是最基础的互斥量，你可以把它理解为一个房间的钥匙，一次只允许一个人（线程）进入。

48.2.1 std::mutex的核心接口

它的用法很直观，主要就三个方法：

• lock()：拿钥匙进门。如果钥匙被别人拿着，那你就在门口等着。
• unlock()：用完房间，把钥匙放回去。务必和lock()配对使用。
• try_lock()：试着拿钥匙。拿得到就进去，拿不到也不傻等，直接告诉你“没拿到”，程序可以继续干别的事。

48.2.2 std::lock_guard：自动管理锁的生命周期

手动调用lock()和unlock()有个大隐患：万一保护区域中间的代码抛出了异常，unlock()可能就没机会执行了，钥匙再也还不回去，其他线程全被堵死，这就是死锁。

好在C++的RAII（资源获取即初始化）理念派上了用场。std::lock_guard这个“警卫”对象，在构造时自动上锁，在析构时（比如离开作用域或发生异常时）自动解锁。有了它，你几乎可以忘记手动解锁这回事。

一个重要的实践准则：在绝大多数情况下，都应该优先使用std::lock_guard，而不是裸调mutex的方法。

48.3 互斥锁实战：解决数据竞争问题

理论说再多，不如代码跑一跑。现在，我们用std::lock_guard来修复开头那个自增计数器的问题。

#include 
#include 
#include 
using namespace std;
int count = 0;
mutex mtx; // 定义全局互斥锁
void increment() {
    for (int i = 0; i < 100000; ++i) {
        lock_guard lock(mtx); // 自动加锁
        count++; // 临界区代码，此时只有一个线程能执行
    } // lock_guard 析构，自动解锁
}
int main() {
    thread t1(increment);
    thread t2(increment);
    t1.join();
    t2.join();
    cout << "最终 count 值：" << count << endl;
    return 0;
}

现在再运行，结果稳稳地定格在200000。互斥锁成功地将count++这个非原子操作变成了一个“原子性”的整体。

48.3.1 关键概念解释

• 临界区：指程序中访问共享资源的那段代码，就像银&行的金库，一次只能进一个人。上面例子中花括号内的部分就是临界区。
• 互斥锁的作用：本质上就是为临界区设立一个“单人间”，确保同一时间只有一个线程在里面执行。

48.4 死锁的产生与规避

互斥锁用不好，会引发一个更棘手的问题：死锁。这就像两个人吵架，每个人都等着对方先道歉，结果谁也等不到。在程序中，就是两个或多个线程互相持有对方需要的锁，导致所有线程都卡住，程序“假死”。

48.4.1 死锁的四个必要条件

死锁的发生不是偶然，它需要同时满足四个条件：

1. 互斥条件：资源本身具有排他性，一个线程用了，别的线程就不能用。
2. 请求与保持条件：线程已经占着一个资源不放，还伸手去要另一个资源。
3. 不可剥夺条件：线程手里的资源，除非自己放手，否则系统不能强行拿走。
4. 循环等待条件：线程之间形成了一个“你等我，我等你”的环形依赖链。

只要打破其中任意一个，死锁就能避免。

48.4.2 死锁的示例

下面这段代码就是一个教科书式的死锁场景：两个线程以相反的顺序去获取两把锁。

#include 
#include 
#include 
using namespace std;
mutex mtx1, mtx2;
void thread1() {
    mtx1.lock();
    this_thread::sleep_for(chrono::milliseconds(100)); // 确保 thread2 先拿到 mtx2
    mtx2.lock(); // 等待 mtx2，此时 thread2 持有 mtx2 并等待 mtx1
    cout << "thread1 执行完毕" << endl;
    mtx2.unlock();
    mtx1.unlock();
}
void thread2() {
    mtx2.lock();
    this_thread::sleep_for(chrono::milliseconds(100)); // 确保 thread1 先拿到 mtx1
    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;
}

运行它，程序会陷入永恒的等待，没有任何输出。

48.4.3 规避死锁的常用方法

知道了原因，对策也就清晰了：

1. 固定锁的获取顺序：这是最有效的方法之一。强制规定所有线程都必须按相同的顺序（比如先mtx1后mtx2）申请锁，这样循环等待的条件就无法形成。
2. 使用 std::lock 同时获取多个锁：标准库提供了std::lock函数，它可以一次性锁定多个互斥量，且保证不会因为获取顺序而产生死锁。通常配合std::lock_guard的adopt_lock标签使用。
3. 使用带超时的锁尝试：如果拿不到锁，别一直傻等。可以用try_lock()尝试，或者使用std::timed_mutex，设置一个等待超时时间，时间一到就放弃，去做些别的处理，避免线程被永久挂起。

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

光说不练假把式，我们用一个更贴近实际的例子来巩固一下：模拟一个多窗口的售票系统。核心要求很简单：100张票，5个窗口同时卖，不能卖超，也不能出现负票。

#include 
#include 
#include 
#include 
using namespace std;
int tickets = 100; // 总票数
mutex mtx;
// 售票函数
void sell_tickets(int window_id) {
    while (true) {
        lock_guard 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 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;
}

运行这个程序，你会看到5个窗口有序地“抢”着售票，从100张到0张，一张不多，一张不少。互斥锁在这里确保了查询票数和减库存这个组合操作是原子的，避免了“一票多卖”的混乱局面。

48.6 本章小结

回顾一下，要安全地进行多线程编程，掌握互斥锁是关键一步：

1. 共享资源的访问必须同步，互斥锁是解决数据竞争的经典方案。
2. std::mutex是基础，但更推荐使用std::lock_guard来自动管理锁生命周期，安全又省心。
3. 警惕死锁。理解其产生的四个条件，并通过固定锁顺序、一次性加锁等策略来规避。
4. 锁的本质是保护临界区，将非原子操作转化为线程安全的原子操作。

互斥锁是并发编程的入门砖，理解它，你就拿到了编写稳健多线程程序的第一把钥匙。