【C++】互斥锁（Mutex）和原子操作（Atomics）

最新推荐文章于 2025-04-12 13:16:32 发布

roman_fan

最新推荐文章于 2025-04-12 13:16:32 发布

阅读量943

点赞数 12

文章标签： c++

本文链接：https://blog.youkuaiyun.com/weixin_40514381/article/details/146523129

版权

详细探讨 C++ 中的并发、多线程、互斥锁（Mutex）和原子操作（Atomics）的概念及其区别，并附带代码示例。

1. C++ 并发与多线程 (Concurrency vs. Multithreading)

并发 (Concurrency)：指系统能够处理多个任务的能力。这些任务的执行可以重叠，但不一定需要同时进行。并发更侧重于逻辑结构，即如何设计程序来应对多个独立的执行流。例如，一个 Web 服务器需要并发地处理多个客户端请求。
多线程 (Multithreading)：是实现并发的一种具体技术。它允许单个进程内存在多个执行线程，这些线程共享进程的内存空间（如代码段、数据段、堆），但拥有各自独立的栈、程序计数器和寄存器。操作系统可以在多个线程之间快速切换（时间分片），或者在多核处理器上并行 (Parallelism) 执行多个线程，从而实现真正的同时执行。

简单来说，并发是问题域（处理多个任务），多线程是解决方案域（用线程实现并发）。

在 C++11 及之后的标准中，通过 <thread>, <mutex>, <atomic>, <future>, <condition_variable> 等头文件提供了标准库级别的并发和多线程支持。

2. 共享数据的问题：竞态条件 (Race Condition)

当多个线程并发访问（至少一个是写入操作）共享数据，并且最终的结果取决于线程执行的相对顺序时，就会发生竞态条件。这通常会导致程序行为不可预测、数据损坏或崩溃。

示例：无保护的计数器

#include <iostream>
#include <thread>
#include <vector>
#include <chrono> // 用于演示潜在问题

long long counter = 0; // 共享变量

void worker(int increments) {
    for (int i = 0; i < increments; ++i) {
        // --- 竞态条件发生点 ---
        // 这一步不是原子操作，它至少包含三步：
        // 1. 读取 counter 的当前值到寄存器
        // 2. 寄存器的值加 1
        // 3. 将寄存器的新值写回 counter
        // 多个线程可能在这些步骤之间交错执行，导致更新丢失
        counter++;
        // --- 竞态条件结束点 ---

        // 稍微增加延迟，更容易观察到竞态条件（实际代码中不应随意加sleep）
        // std::this_thread::sleep_for(std::chrono::nanoseconds(1));
    }
}

int main() {
    const int num_threads = 10;
    const int increments_per_thread = 100000;
    std::vector<std::thread> threads;

    for (int i = 0; i < num_threads; ++i) {
        threads.emplace_back(worker, increments_per_thread);
    }

    for (auto& t : threads) {
        t.join();
    }

    long long expected_value = (long long)num_threads * increments_per_thread;
    std::cout << "Expected counter value: " << expected_value << std::endl;
    std::cout << "Actual counter value:   " << counter << std::endl; // 很可能小于预期值

    return 0;
}

运行上述代码，你会发现 Actual counter value 几乎总是小于 Expected counter value。这就是因为 counter++ 操作不是原子的，多个线程同时读写导致了更新丢失。

为了解决竞态条件，我们需要同步机制，其中最常用的就是互斥锁和原子操作。

3. 互斥锁 (Mutex - Mutual Exclusion)

概念：互斥锁是一种同步原语，用于保护临界区 (Critical Section)——即访问共享资源的代码段。同一时刻，只有一个线程能获得（锁定）互斥锁。其他试图获取该锁的线程会被阻塞，直到持有锁的线程释放（解锁）它。
工作方式：
1. 线程在进入临界区之前尝试 lock() 互斥锁。
2. 如果锁未被持有，该线程获得锁并进入临界区。
3. 如果锁已被其他线程持有，该线程阻塞（挂起），等待锁被释放。
4. 线程完成临界区操作后，必须 unlock() 互斥锁，以便其他等待的线程可以获取它。
C++ 实现：
- std::mutex: 基本的互斥锁。
- std::recursive_mutex: 允许同一线程多次锁定，但必须对应次数解锁。
- std::timed_mutex: 允许尝试在一定时间内锁定 (try_lock_for, try_lock_until)。
- std::recursive_timed_mutex: 结合了 recursive 和 timed 特性。
RAII (Resource Acquisition Is Initialization) 包装器：直接使用 lock() 和 unlock() 容易忘记解锁，尤其是在有异常抛出的情况下。C++ 提供了 RAII 风格的锁管理类，它们在构造时自动获取锁，在析构时自动释放锁，大大提高了安全性。
- std::lock_guard<Mutex>: 构造时锁定，析构时解锁。简单直接，不支持手动解锁或转移所有权。
- std::unique_lock<Mutex>: 功能更强大，支持延迟锁定、尝试锁定、定时锁定、手动解锁、移动所有权（可以用于条件变量）。

示例：使用 std::mutex 和 std::lock_guard 保护计数器

#include <iostream>
#include <thread>
#include <vector>
#include <mutex> // 包含互斥锁头文件

long long counter_mutex = 0; // 共享变量
std::mutex mtx;           // 定义一个互斥锁实例

void worker_mutex(int increments) {
    for (int i = 0; i < increments; ++i) {
        // 使用 lock_guard 自动管理锁的生命周期
        // 当 lock 对象创建时，它会调用 mtx.lock()
        std::lock_guard<std::mutex> lock(mtx);

        // --- 临界区开始 ---
        // 现在只有一个线程能执行这里的代码
        counter_mutex++;
        // --- 临界区结束 ---

        // 当 lock 对象离开作用域（在此次循环迭代结束时），
        // 其析构函数会自动调用 mtx.unlock()
    }
}

int main() {
    const int num_threads = 10;
    const int increments_per_thread = 100000;
    std::vector<std::thread> threads;

    for (int i = 0; i < num_threads; ++i) {
        threads.emplace_back(worker_mutex, increments_per_thread);
    }

    for (auto& t : threads) {
        t.join();
    }

    long long expected_value = (long long)num_threads * increments_per_thread;
    std::cout << "Mutex - Expected counter value: " << expected_value << std::endl;
    std::cout << "Mutex - Actual counter value:   " << counter_mutex << std::endl; // 现在结果总是正确的

    return 0;
}

使用互斥锁后，Actual counter value 将始终等于 Expected counter value，因为对 counter_mutex 的访问被正确地序列化了。

4. 原子操作 (Atomic Operations)

概念：原子操作是指不可中断的操作。从其他线程的角度看，原子操作要么完全执行完毕，要么根本没有执行，不存在中间状态。它们通常由特殊的 CPU 指令实现，比使用互斥锁的开销要小得多，尤其是在低争用情况下。
工作方式：原子操作直接作用于内存位置，硬件保证其执行的原子性。例如，一个原子的 fetch_add (或 operator++) 指令可以在单个、不可分割的步骤中完成读取、增加和写回的操作。
C++ 实现：
- std::atomic<T>: 模板类，可以用于封装任何可平凡复制 (Trivially Copyable) 的类型 T（如 int, bool, float, 指针等），并为其提供原子操作。
- 提供了多种原子操作，如 load, store, exchange, compare_exchange_weak/compare_exchange_strong, fetch_add, fetch_sub 等。
- std::atomic_flag: 一个简单的原子布尔标志，保证是无锁 (lock-free) 的。
内存序 (Memory Order)：原子操作还可以指定内存序 (std::memory_order)，用于控制编译器和处理器如何重排指令以及内存操作对其他线程的可见性。这是原子操作中比较复杂的部分，默认的 std::memory_order_seq_cst（顺序一致性）提供了最强的保证（所有线程看到的原子操作顺序一致），但可能性能最低。其他内存序（如 relaxed, acquire, release, acq_rel）允许更宽松的重排，可能提高性能，但需要非常小心地使用以避免引入微妙的错误。

示例：使用 std::atomic 保护计数器

#include <iostream>
#include <thread>
#include <vector>
#include <atomic> // 包含原子操作头文件

// 使用 std::atomic 封装共享变量
std::atomic<long long> atomic_counter = 0;

void worker_atomic(int increments) {
    for (int i = 0; i < increments; ++i) {
        // 对 std::atomic 类型的 ++ 操作是原子的
        // 它通常会被编译成一条特殊的原子指令 (如 x86 的 LOCK INC)
        // 或者使用 CAS (Compare-And-Swap) 循环实现
        atomic_counter++;
        // 或者显式调用 fetch_add:
        // atomic_counter.fetch_add(1, std::memory_order_seq_cst); // 默认内存序
    }
}

int main() {
    const int num_threads = 10;
    const int increments_per_thread = 100000;
    std::vector<std::thread> threads;

    for (int i = 0; i < num_threads; ++i) {
        threads.emplace_back(worker_atomic, increments_per_thread);
    }

    for (auto& t : threads) {
        t.join();
    }

    long long expected_value = (long long)num_threads * increments_per_thread;
    std::cout << "Atomic - Expected counter value: " << expected_value << std::endl;
    std::cout << "Atomic - Actual counter value:   " << atomic_counter.load() << std::endl; // 结果总是正确的
                                                                                              // 读取原子变量也需要用 load() 或隐式转换

    // 检查原子类型是否无锁
    std::cout << "std::atomic<long long> is lock-free? "
              << (atomic_counter.is_lock_free() ? "Yes" : "No") << std::endl;
    // 在大多数现代平台上，对于内建类型（如 int, long long, bool, 指针）的原子操作通常是无锁的

    return 0;
}

使用 std::atomic 后，Actual counter value 同样始终等于 Expected counter value。

5. 互斥锁 vs. 原子操作：区别总结

特性	互斥锁 (Mutex)	原子操作 (Atomics)
机制	基于操作系统的锁机制（通常涉及系统调用）	通常基于硬件指令（CPU 特殊指令）
保护对象	保护代码块（临界区），可以包含复杂逻辑和多个变量	保护对单个变量的访问操作
粒度	较粗	较细
阻塞行为	线程获取不到锁时会阻塞（挂起，让出 CPU）	通常是非阻塞的（或短暂自旋），不让出 CPU（除非是争用激烈时的自旋锁实现或非无锁原子）
性能开销	较高（涉及上下文切换、内核调用）	通常较低（尤其是无锁原子操作），但高争用下 CAS 可能变慢
死锁风险	有可能发生死锁（如 A 等 B 的锁，B 等 A 的锁）	原子操作本身不会导致死锁
适用场景	保护复杂操作、多个共享变量、I/O 操作等	简单计数器、标志位、指针更新、状态机转换等简单操作
复杂度	概念相对简单，但需小心死锁和锁的粒度	基本使用简单，但内存序 (`memory_order`) 的概念复杂且易错
无锁性	总是有锁的 (Blocking)	可能是无锁 (Lock-free) 的（不保证所有类型/平台）

关键选择依据：

保护范围：
- 如果你需要保护一个涉及多条语句、多个变量或复杂逻辑的临界区，使用互斥锁。例如，从一个队列弹出元素，然后更新队列大小和状态。
- 如果你只需要对单个变量执行简单的、不可分割的操作（如增减、读取、写入、比较并交换），使用原子操作通常更高效。
性能考虑：
- 对于简单操作和低到中等程度的线程争用，原子操作通常性能更好，因为它们避免了阻塞和上下文切换的开销。
- 在高争用情况下，原子操作（尤其是基于 CAS 的）可能会因为不断重试而消耗大量 CPU 周期（称为“活锁”或“自旋”现象），此时性能可能不如互斥锁（因为互斥锁会让线程睡眠，释放 CPU）。但是，现代 CPU 的原子指令优化得越来越好。
- 互斥锁的开销相对固定，但比无争用的原子操作要高。
死锁：
- 使用多个互斥锁时，必须非常小心锁的获取顺序，否则容易导致死锁。
- 原子操作本身不会引起死锁。

总结：

互斥锁和原子操作都是 C++ 中处理并发访问共享数据的重要工具。互斥锁提供了基于阻塞的、通用的临界区保护机制，适用于保护复杂的代码段。原子操作则提供了基于硬件指令的、通常更高效的、针对单个变量的不可分割操作。理解它们的区别和适用场景，是编写正确、高效的并发程序的关键。在现代 C++ 中，应优先考虑使用 std::atomic 来处理简单的共享状态（如标志、计数器），而将 std::mutex 用于保护更复杂的临界区。