c++中的std::atomic怎么使用_c++ std::atomic使用方法

std::atomic提供线程安全的原子操作，支持基本类型的读写、修改、比较交换及内存序控制，用于避免数据竞争，实现高效无锁编程。

在C++中，std::atomic 用于实现线程安全的原子操作，避免多个线程同时访问共享变量时出现数据竞争。它定义在 头文件中，适用于布尔值、整数、指针等基本类型。

1. 基本用法：声明和初始化

可以使用 std::atomic 来包装支持原子操作的基本类型：

• 整型：int、long、bool 等
• 指针类型

#include 
#include 

std::atomic counter{0};     // 初始化为0
std::atomic ready{false};  // 布尔标志
std::atomic ptr{nullptr};  // 原子指针

2. 原子读写操作

默认情况下，load() 和 store() 提供原子读取和写入：

counter.store(10);        // 原子写入
int value = counter.load(); // 原子读取

也可以使用赋值和解引用操作符（但建议明确调用 load/store 以增强可读性）：

立即学习“C++免费学习笔记（深入）”；

counter = 5;              // 等价于 store(5)
int val = counter;        // 等价于 load()

3. 原子修改操作（常用在计数器场景）

支持自增、自减、加减等操作，常用于多线程计数：

Baklib

在线创建产品手册、知识库、帮助文档

下载

• fetch_add(n)：返回旧值，然后加 n
• fetch_sub(n)：返回旧值，然后减 n
• operator++() 和 operator--()：前置版本是原子的

#include 
#include 

void increment(std::atomic& cnt) {
    for (int i = 0; i < 1000; ++i) {
        cnt++;  // 原子自增
    }
}

int main() {
    std::atomic cnt{0};
    std::vector threads;

    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(increment, std::ref(cnt));
    }

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

    std::cout << "Final count: " << cnt.load() << "\n";
    return 0;
}

4. 比较并交换（CAS）：实现无锁逻辑

compare_exchange_weak() 和 compare_exchange_strong() 是实现无锁编程的核心：

bool success = counter.compare_exchange_weak(expected, desired);

如果当前值等于 expected，则设为 desired，并返回 true；否则将 expected 更新为当前值，返回 false。

int expected = counter.load();
int desired;
do {
    desired = expected + 1;
} while (!counter.compare_exchange_weak(expected, desired));

这段代码实现了安全的自增，即使在并发环境下也不会出错。

5. 内存序（Memory Order）控制

所有原子操作都可以指定内存顺序，控制同步行为和性能：

• memory_order_relaxed：最弱，仅保证原子性
• memory_order_acquire / release：用于同步线程间的数据访问
• memory_order_seq_cst：默认，最强一致性（顺序一致性）

std::atomic flag{false};
int data = 0;

// 线程1：写数据
data = 42;
flag.store(true, std::memory_order_release);

// 线程2：读数据
if (flag.load(std::memory_order_acquire)) {
    std::cout << data << "\n";  // 安全读取
}

基本上就这些。std::atomic 不复杂但容易忽略细节，正确使用能有效提升多线程程序性能与安全性。注意不是所有类型都支持原子操作，复杂对象应配合互斥锁使用。