C++互斥锁原理、std::lock_guard 与死锁防范

从资源共享到线程安全

在多任务操作系统中，多个线程往往需要同时操作同一块内存区域（如容器或文件）。如果读写操作不同步，就会出现数据不一致的情况。以一个模仿消息队列的列表为例：

• 写线程：将整数插入列表尾部；
• 读线程：读取并删除列表头部的元素。

若不加保护，当写线程尚未完成“插入”操作而上下文切换到读线程时，读到的可能是未初始化的垃圾数据或部分更新的节点，导致程序崩溃或逻辑错误。

为了解决这个问题，必须引入互斥锁（Mutex），确保在同一时刻只有一个线程能修改该共享资源。

互斥锁的核心机制

1. 互斥锁的特点

std::mutex 主要用于保护共享资源，具有以下三个关键特性：

• 原子性：锁定操作是原子的。一旦线程 A 获得锁，其他线程无法同时获得。
• 唯一性：在被解锁前，锁只能被持有它的线程释放，其他线程尝试获取会被阻塞。
• 非繁忙等待：等待锁的线程会被挂起，不占用 CPU 资源，直到锁被释放后重新被唤醒。

2. 精确加锁：避免串行化与性能损耗

为了正确使用锁，必须明确“临界区”的范围。以下代码展示了一个错误的加锁示例：

void WriteList() {
    mtx.lock(); // 在循环外加锁
    for (int i = 0; i < 100000; i++) {
        mylist.push_back(i);
    }
    mtx.unlock();
}

这种做法会导致整个写入过程被串行化，失去了多线程并发的意义，且大幅降低性能。正确的做法是将锁放在具体的读写操作附近：

void WriteList() {
    for (int i = 0; i < 100000; i++) {
        mtx.lock();           // 进入临界区
        cout << "Write : " << i;
        mylist.push_back(i);
        mtx.unlock();         // 离开临界区
    }
}

3. 常见的竞态条件陷阱

即使是将锁放在循环内，也可能出现意外结果。假设有两个线程向列表写入，由于i < 1000的判断与自增操作之间未被整体锁住，可能出现这种情况：

1. 两个线程均检查i < 1000为真；
2. 线程 A 拿到锁，执行到i++使i=1000后释放锁；
3. 线程 B 随即拿到锁，虽然i已为 1000，但仍会执行一次写入操作。

展示了无锁情况下的输出混乱，而 展示了仅包裹操作带来的微小计数偏差。

要彻底修复，必须在锁内部重新判断条件，并在异常退出时保证解锁：

void WriteList() {
    while (i < 10000) {
        m.lock();
        if (i >= 10000) {
            m.unlock(); // 注意分支处的解锁
            break;
        }
        mylist.push_back(i++);
        m.unlock();
    }
}

4. 智能锁管理器：std::lock_guard

手动调用lock()和unlock()容易因代码分支导致遗漏解锁，从而引发程序报错。推荐使用 std::lock_guard<mutex>，它利用 RAII（资源获取即初始化）机制，在对象构造时自动加锁，析构时自动解锁。

void WriteList() {
    while (i < 10000) {
        lock_guard<mutex> guard(m); // 构造即加锁
        if (i >= 10000) {
            break; // 退出大括号范围时，guard 析构并自动解锁
        }
        mylist.push_back(i++);
    } // guard 在此处销毁，释放锁
}

死锁的成因与防范

当多个线程试图以不同的顺序获取多个互斥锁时，就可能发生死锁。例如线程 1 先拿 A 再拿 B，线程 2 先拿 B 再拿 A，两者互相等待对方手中的锁，导致程序永久挂起。

防范方案一：保持加锁顺序一致

最简单的方法是规定所有线程必须按照固定的顺序请求锁。让线程 2 也改为先拿 A 再拿 B。

防范方案二：原子式多锁获取（std::lock）

若无法确定统一的顺序，可以使用 std::lock() 函数一次性获取多个锁。它会返回已经加锁的状态，然后配合 adopt_lock 告知 lock_guard 锁已被占有。

// 线程函数示例
while (i < 100) {
    lock(m0, m1); // 原子地尝试获取两个锁
    lock_guard<mutex> g0(m0, adopt_lock);
    lock_guard<mutex> g1(m1, adopt_lock);
    // 执行安全操作...
} // 析构自动释放 m0 和 m1

以上就是 C++ 多线程之互斥锁与死锁的详细内容，更多关于 C++ 并发编程 线程同步 的资料请关注本站其它相关文章！