C++中的并发编程（线程与原子操作）（二）

目录

一、C++中的原子操作

原子操作概念：

C++标准库中的原子类型与操作：

头文件：

原子操作函数：

原子操作的内存序：

原子操作的应用场景：

二、并发编程的最佳实践与挑战

最佳实践

常见挑战与对策

---

一、C++中的原子操作

原子操作概念：

原子操作是指在多线程环境中，一个操作或者一系列操作被视为不可分割的整体，即该操作从开始到结束不会被其他线程所干扰，始终以一个不可中断的单元完成。这种性质确保了即使多个线程同时访问同一共享数据，原子操作也能保证数据的一致性和完整性，不会出现数据竞争（data race）或中间状态。

在并发编程中，原子操作对于保证数据一致性、避免竞态条件至关重要。竞态条件是指由于多个线程对共享资源的访问顺序不确定而导致的结果不一致现象。例如，两个线程同时尝试增加一个共享计数器，如果没有适当的同步机制，可能会导致计数结果错误。原子操作通过内在硬件支持（如处理器的CAS指令）或编译器提供的同步原语，确保此类操作在没有外部同步（如锁）的情况下也能正确执行，从而消除竞态条件，提升并发程序的正确性和性能。

C++标准库中的原子类型与操作：

<atomic>头文件：

C++11引入了<atomic>头文件，其中定义了std::atomic模板类，用于声明和使用原子变量。std::atomic支持多种数据类型，包括整型、布尔型、指针型等，例如：

• 原子整型：std::atomic<int>、std::atomic<unsigned long>等。
• 原子布尔型：std::atomic<bool>。
• 原子指针型：std::atomic<T*>，其中T是所指向的对象类型。

原子操作函数：

std::atomic模板类提供了多种原子操作函数，用于对原子变量进行读写和比较交换等操作：

• load()：以原子方式读取原子变量的值，可以指定内存顺序。
• store()：以原子方式设置原子变量的值，同样可指定内存顺序。
• exchange()：以原子方式用新值替换原子变量的当前值，并返回旧值，支持内存顺序控制。
• compare_exchange_strong() 和 compare_exchange_weak()：原子地比较原子变量的当前值与预期值，若两者相等，则将原子变量的值更新为新值，否则保留原值。这两个函数的区别在于弱版本可能因优化原因偶尔失败，而强版本总是可靠地反映比较结果。两者都返回比较是否成功的布尔值，并可指定内存顺序。

原子操作的内存序：

内存顺序标记（memory order）是原子操作的重要组成部分，用于指定原子操作相对于其他内存操作的可见性和排序关系。C++标准定义了以下几种常见的内存顺序类型：

• memory_order_relaxed：仅保证操作本身的原子性，不提供任何同步屏障，对其他操作的可见性没有约束。
• memory_order_acquire：确保原子读操作（如load()）之后的代码能够看到此读操作之前（按照程序顺序）所有具有memory_order_release或memory_order_seq_cst的写操作的结果。
• memory_order_release：确保原子写操作（如store()）之前（按照程序顺序）的所有操作结果对其他线程中后续的memory_order_acquire或memory_order_seq_cst读操作可见。
• memory_order_seq_cst（顺序一致）：提供最强的同步保证，既包含acquire和release的特性，还保证所有线程对seq_cst操作的观察顺序一致。这是默认的内存顺序。

选择合适的内存顺序取决于具体的同步需求。例如：

• 当仅需要保护一个简单计数器的递增时，可以使用memory_order_relaxed以获取最佳性能，因为计数器的最终值并不依赖于递增操作的精确排序。
• 在构建无锁数据结构，如无锁队列的入队和出队操作时，通常需要memory_order_acquire和memory_order_release来建立有效的生产和消费之间的同步关系，确保元素的添加和移除操作对其他线程的可见性。
• 对于需要全局一致性的关键状态变更，应使用memory_order_seq_cst，以确保所有线程对这些操作的观察顺序是一致的，避免复杂的竞态条件。

原子操作的应用场景：

原子操作在实现无锁数据结构、细粒度同步等并发编程实践中具有广泛应用：

• 无锁队列：原子操作可以用来构建无锁的FIFO队列，例如使用原子指针实现链表节点的入队和出队操作。入队时，原子地更新尾节点指针并将新节点链接到链表末尾；出队时，原子地交换头节点指针并返回旧头节点。通过恰当选择内存顺序，确保在无锁情况下队列操作的正确性和线程安全性。

• 无锁计数器：原子整型常用于实现无锁计数器。如原子地递增或递减一个整数，用于统计事件次数、管理资源引用计数等。只需对计数器执行fetch_add(1, memory_order_relaxed)（递增）或fetch_sub(1, memory_order_relaxed)（递减）即可安全地在多线程环境下更新计数。

• 细粒度同步：原子操作允许开发者在更细的粒度上进行同步，避免使用昂贵的互斥锁。例如，在复杂的多状态协作场景中，可以通过原子变量和相应的原子操作（如compare_exchange_strong()）实现状态机的无锁转移，提高系统的并发性能。

综上所述，C++中的原子操作通过std::atomic模板类及其提供的各种原子操作函数，为并发编程提供了基础的同步原语。合理使用原子操作不仅可以有效防止数据竞争和竞态条件，还能在许多场景下替代传统的锁机制，实现高效、无阻塞的并发代码。选择恰当的内存顺序对于确保正确的同步行为至关重要，有助于编写出既正确又高效的并发程序。

二、并发编程的最佳实践与挑战

最佳实践

编写并发C++程序时应遵循的原则：

最小化共享数据：尽可能减少线程间的共享数据，特别是临界区（critical section）内的数据。通过将任务分解为独立的工作单元，每个单元拥有自己的数据，从而减少竞争和同步需求。对于必须共享的数据，应使用适当的同步机制进行保护。

示例：

std::mutex mtx;
std::vector<int> sharedData;

void threadFunction() {
    std::lock_guard<std::mutex> lock(mtx);
    // 对sharedData进行安全访问和修改
}

优先使用高级同步原语：如std::atomic、std::mutex、std::condition_variable等C++标准库提供的工具，而非低级别的系统原语（如POSIX互斥量、信号量等）。这些高级原语通常经过优化，提供更好的可移植性和易用性。

示例：

std::atomic<bool> flag(false);

void threadA() {
    while (!flag.load(std::memory_order_acquire)) { /* 等待 */ }
    // 执行任务
}

void threadB() {
    // 准备任务数据
    flag.store(true, std::memory_order_release); // 通知线程A
}

避免死锁：确保线程持有锁的顺序一致，避免循环等待资源。使用锁层次结构、死锁预防算法（如资源排序、死锁检测）或避免嵌套锁。对于可能的死锁情况，设置合理的超时时间。

示例：

std::mutex mtxA, mtxB;

void threadFunction() {
    std::unique_lock<std::mutex> lockA(mtxA, std::defer_lock);
    std::unique_lock<std::mutex> lockB(mtxB, std::defer_lock);

    std::lock(lockA, lockB); // 保证同时或按固定顺序获取锁
    // 执行临界区操作
}

使用RAII（Resource Acquisition Is Initialization）技术：如std::lock_guard、std::unique_lock等，确保锁在作用域结束时自动释放，防止忘记解锁导致的资源泄漏或死锁。

适当使用异步编程模型：如std::future、std::async、std::promise等，将耗时操作异步执行，提高程序响应性。注意管理future的状态和生命周期，避免悬挂。

常见挑战与对策

竞态条件：

• 产生原因：多个线程对同一数据进行非原子操作，导致结果依赖于线程调度顺序，引发数据不一致或错误行为。

• 危害：数据损坏、逻辑错误、程序崩溃，严重时可能导致系统不稳定。

• 预防手段：

  • 使用std::atomic对关键数据进行原子操作。
  • 用同步原语（如互斥量）保护临界区，确保同一时刻只有一个线程访问。
  • 尽量避免在循环体、条件语句中进行非原子操作。

死锁：

• 形成条件：互斥条件（每个资源至少被一个线程占有且不释放）、不可抢占条件（已获得资源的线程不主动释放）、循环等待条件（线程间形成环形等待关系）同时成立时，发生死锁。

• 预防方法：

  • 资源排序：为资源分配全局唯一的序号，各线程按照序号递增顺序申请资源。
  • 超时设置：对锁的获取操作设置超时时间，超时后释放已获取资源并回滚或重试。
  • 死锁检测：使用专门的算法或工具定期检查线程状态，发现死锁时采取相应措施（如撤销操作、唤醒阻塞线程）。

活锁与饥饿：

• 活锁：线程间不断尝试获取资源，但因互相礼让（如回退策略）导致都无法继续执行，陷入循环等待状态。

• 饥饿：某个线程长时间无法获得所需资源而无法进展，即使其他线程释放了资源，也总是被其他线程抢先获取。

• 避免策略：

  • 随机退避：在回退策略中引入随机因素，避免线程间同步“跳舞”。
  • 优先级继承/升迁：当高优先级线程因等待低优先级线程持有的资源而阻塞时，暂时提升低优先级线程的优先级，使其尽快释放资源。
  • 公平锁：确保线程获取锁的顺序与其请求锁的顺序大致相同，防止某个线程长期被忽视。例如，std::mutex默认为非公平锁，但可以通过构造函数参数选择公平锁。