异常教程

C++ 标准库 <atomic>（一文讲透）

更新时间:

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

  • 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;
  • 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 82w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 2900+ 小伙伴加入学习 ，欢迎点击围观

在现代软件开发中，多线程编程已成为提升程序性能和响应能力的关键技术。然而，多线程环境下的数据竞争问题，常常导致程序行为不可预测，甚至引发崩溃或逻辑错误。为解决这一难题，C++11引入了 <atomic> 标准库，提供了原子操作（Atomic Operations）的底层支持。本文将从基础概念出发，结合实际案例，深入浅出地解析 <atomic> 标准库的核心功能、使用场景及最佳实践，帮助读者在多线程编程中构建安全、高效的代码结构。

原子操作：多线程环境下的“交通灯”

原子操作是多线程编程中的核心概念，它保证对某个内存位置的访问和修改是“不可分割”的。想象一个繁忙的十字路口：若没有交通灯，车辆可能因争抢通行权而引发事故。原子操作的作用，就类似于这个“交通灯”，通过确保操作的原子性，避免线程间的数据竞争（Data Race）。

在C++中，<atomic> 标准库通过 std::atomic 类模板实现了这一功能。例如：

#include <atomic>  
std::atomic<int> counter(0); // 声明一个原子类型的整数  
counter.fetch_add(1);        // 原子性地将counter的值加1

原子操作的特性

原子操作具备以下核心特性：

  1. 不可分割性：操作在执行期间不会被其他线程中断。
  2. 内存顺序保证：通过内存模型（Memory Model）控制不同线程间可见性与时序。
  3. 跨平台兼容性：底层实现由编译器和硬件共同优化，无需开发者手动处理汇编指令。

<atomic> 标准库的核心功能

1. 原子变量的声明与基本操作

原子变量通过 std::atomic<T> 定义，支持大多数基础类型（如 int、bool、指针等），但不支持自定义类型。其基本操作包括：

操作类型描述示例代码
读取操作load()：原子性读取变量值int value = counter.load();
写入操作store(value)：原子性写入新值counter.store(10);
增减操作fetch_add(delta)：返回旧值后加deltaint old_val = counter.fetch_add(1);
比较交换compare_exchange_weak(expected, desired)：若当前值等于expected则替换counter.compare_exchange_weak(expected, new_val);

示例：线程安全的计数器

#include <atomic>  
#include <thread>  

std::atomic<int> shared_counter(0);  

void increment() {  
    for (int i = 0; i < 1000; ++i) {  
        shared_counter.fetch_add(1); // 原子操作，避免竞争  
    }  
}  

int main() {  
    std::thread t1(increment);  
    std::thread t2(increment);  
    t1.join(); t2.join();  
    std::cout << "Final count: " << shared_counter.load() << std::endl; // 输出应为2000  
    return 0;  
}

2. 内存顺序（Memory Order）

原子操作的内存顺序决定了线程间对变量的可见性与时序约束。C++提供了5种内存顺序选项，其中最常用的是：

内存顺序选项适用场景特性描述
memory_order_relaxed无序操作，仅保证原子性，不保证可见性与顺序类似“交通灯关闭”，线程可自由调度，但数据可能不即时可见
memory_order_acquire读操作时，保证后续读取的变量可见性类似“绿灯通行”，确保当前线程看到其他线程的写入结果
memory_order_release写操作时，保证当前线程的修改对其他线程可见类似“红灯停止”，确保当前线程的写入结果被其他线程读取到
memory_order_acq_rel结合acquire和release，适用于读写操作类似“绿灯通行+红灯停止”，确保双向可见性与顺序约束
memory_order_seq_cst强制全局顺序，所有原子操作按程序顺序执行类似“精确时钟同步”，保证所有线程观察到一致的操作序列

示例：使用 memory_order 控制线程同步

std::atomic<bool> ready(false); // 使用默认的memory_order_seq_cst  

void worker() {  
    while (!ready.load(std::memory_order_acquire)) { // 使用acquire确保可见性  
        std::this_thread::yield();  
    }  
    // 执行任务  
}  

void coordinator() {  
    prepare_resources();  
    ready.store(true, std::memory_order_release); // 使用release确保写入可见  
}

3. 原子指针与复合类型

<atomic> 支持原子指针操作（如 std::atomic<void*>），但对复合类型（如结构体、类）需谨慎使用。若需原子操作复合类型，可通过封装实现：

struct MyData {  
    int x;  
    double y;  
};  

std::atomic<MyData*> atomic_ptr(nullptr); // 原子指针安全  
atomic_ptr.store(new MyData{1, 2.0});     // 原子性写入指针

高级应用：构建线程安全的数据结构

1. 原子操作实现线程安全队列

通过原子操作与CAS（Compare-And-Swap）指令，可构建无锁队列：

template<typename T>  
class LockFreeQueue {  
    struct Node {  
        std::atomic<Node*> next;  
        T data;  
        Node(const T& val) : data(val), next(nullptr) {}  
    };  

    std::atomic<Node*> head;  
    Node* tail;  

public:  
    LockFreeQueue() : head(new Node(T{})), tail(head.load()) {}  

    void push(const T& val) {  
        Node* new_node = new Node(val);  
        Node* old_tail = tail;  
        old_tail->next.compare_exchange_weak(nullptr, new_node);  
        tail = new_node;  
    }  

    T pop() {  
        Node* old_head = head.load();  
        while (true) {  
            Node* next_head = old_head->next.load();  
            if (head.compare_exchange_weak(old_head, next_head)) {  
                T value = next_head->data;  
                delete old_head;  
                return value;  
            }  
        }  
    }  
};

2. 原子标志实现线程间协作

通过原子布尔值控制线程的启动与停止：

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

void worker_thread() {  
    while (!stop_flag.load(std::memory_order_acquire)) {  
        process_task();  
    }  
    cleanup_resources();  
}  

void shutdown() {  
    stop_flag.store(true, std::memory_order_release);  
}

常见误区与最佳实践

误区1：过度依赖原子操作

原子操作虽然线程安全，但频繁使用可能引入性能瓶颈。例如，对同一变量的高频率原子操作可能导致缓存行（Cache Line）的频繁无效化（Cache Invalidation）。此时，可考虑：

  • 使用局部变量减少共享数据访问
  • 通过锁机制（如 std::mutex）实现更细粒度的控制

误区2：忽略内存顺序的影响

默认的 memory_order_seq_cst 虽然安全，但会强制全局顺序，可能降低性能。应根据场景选择合适的内存顺序：

  • 对于读写分离的场景，可尝试 memory_order_acquire 和 memory_order_release
  • 在无序操作中，可使用 memory_order_relaxed

最佳实践

  1. 优先使用标准库同步原语：如 std::atomic_flag、std::atomic_shared_ptr 等，避免直接操作底层原子类型。
  2. 结合锁与原子操作：例如，使用原子操作实现“锁-自由”（Lock-Free）算法，或通过“乐观锁”（Optimistic Locking）减少阻塞时间。
  3. 测试与验证：通过多线程压力测试（如使用 std::jthread 和 std::stop_token）确保代码的正确性。

结论

<atomic> 标准库是C++多线程编程中不可或缺的工具，它通过原子操作和内存模型，为开发者提供了高效、安全的并发控制手段。从基础的计数器到复杂的无锁数据结构，原子操作的应用场景广泛且灵活。然而，其正确使用需要对内存模型和线程同步机制有深刻理解。

对于初学者，建议从简单案例入手，逐步掌握原子操作的核心概念；中级开发者则可结合实际需求，探索原子操作与锁机制的混合使用场景。随着对 <atomic> 标准库的深入理解，开发者将能够编写出更健壮、高性能的多线程程序，充分释放现代处理器的并行计算能力。

提示：若想进一步学习多线程编程，可参考《C++ Concurrency in Action》或深入研究C++内存模型的官方文档。

最新发布

查看更多文章