volatile 是 C/C++ 中的一个关键字，用于告知编译器某个变量的值可能会在程序的控制之外被意外修改（例如被硬件、中断服务程序、多线程环境或其他外部代理）。为了防止编译器对代码进行某些可能破坏程序正确性的优化，开发者需要使用 volatile 来强制编译器在每次访问该变量时都直接从内存中读取或写入，而不是依赖寄存器中的缓存值或优化掉“看似冗余”的访问。

std::atomic 是 C++11 引入的一个模板类，用于在多线程环境中实现原子操作。它确保对共享变量的操作是线程安全的，并且可以控制内存顺序（memory order）。

volatile

1. 禁用编译器优化：

• 编译器通常会对变量访问进行优化，例如将变量缓存到寄存器中以提高访问速度。
• volatile 会强制编译器每次访问变量时都从内存中读取或写入，确保获取最新值。

1. 典型应用场景：

• 硬件寄存器：嵌入式系统中，硬件状态可能通过内存映射的寄存器被外部修改。

// 假设 0x4000 是某个硬件寄存器的内存映射地址
volatile uint32_t* const hardware_reg = reinterpret_cast<volatile uint32_t*>(0x4000);

void read_hardware() {
    // 每次读取都会直接从硬件寄存器获取最新值
    uint32_t value = *hardware_reg;
}

• 中断服务程序（ISR）：中断可能修改共享变量。

volatile bool data_ready = false; // 中断可能修改此变量

void ISR() {
    data_ready = true; // 中断触发时修改
}

int main() {
    while (!data_ready) { // 每次循环都从内存读取最新值
        // 等待数据准备就绪
    }
}

• 多线程共享变量（但需注意，volatile 不能替代线程同步机制，多线程中仍需使用 std::atomic 或互斥锁）。

volatile bool flag = false;

// 线程 A
void thread_a() {
    flag = true; // 修改标志
}

// 线程 B
void thread_b() {
    while (!flag) { // 读取标志
        // 等待
    }
}

std::atomic的常用操作

• 加载（Load）：

int value = counter.load(std::memory_order_relaxed);

• 存储（Store）：

counter.store(42, std::memory_order_relaxed);

• 交换（Exchange）：

int old_value = counter.exchange(100);

• 比较并交换（Compare-and-Swap, CAS）：

int expected = 10;
bool success = counter.compare_exchange_strong(expected, 20);

• 原子加减：

counter.fetch_add(5);  // 原子加 5
counter.fetch_sub(3);  // 原子减 3

内存顺序（Memory Order）

std::atomic 支持多种内存顺序，用于控制操作的可见性和顺序性。常用的内存顺序包括：

• std::memory_order_relaxed：只保证原子性，不保证顺序。
• std::memory_order_acquire：保证后续操作不会重排到该操作之前。
• std::memory_order_release：保证前面的操作不会重排到该操作之后。
• std::memory_order_seq_cst：最严格的内存顺序，保证全局顺序一致性。

counter.store(42, std::memory_order_release);
int value = counter.load(std::memory_order_acquire);

std::atomic应用场景

• std::atomic 是 C++ 中实现线程安全操作的首选工具
• 它提供了原子操作和内存顺序控制，适用于多线程环境中的共享变量。
• 与 volatile 不同，std::atomic 不仅保证原子性，还提供了更强的内存顺序保证。

std::atomic与volatile的区别总结