原子操作与内存序
原子操作与内存序
一、原子操作与锁概述
在多线程编程中,保证共享数据的一致性是一个核心问题。传统的解决方案是使用锁(互斥锁、读写锁等),但锁会带来线程阻塞、上下文切换等开销。在某些高性能场景下,我们希望采用更轻量的同步机制——原子操作。
原子操作是不可分割的操作单元,即操作要么全部完成,要么完全没有执行,不会出现中间状态被其他线程观测到的情况。原子操作通常由硬件直接支持,配合内存序(memory order)约束,可以实现无锁编程,提升并发性能。
二、原子操作基础
2.1 什么是原子操作
原子操作是指在执行过程中不会被线程调度机制打断的操作,一旦开始就会一直运行到结束,中间不会发生上下文切换。在现代CPU中,原子操作通常通过特殊的指令(如x86的LOCK前缀)或硬件协议(如缓存一致性)来保证。
2.2 原子变量与原子操作类型
C++11开始,标准库提供了std::atomic模板,可以定义原子类型的变量。支持的类型包括:
- 整型:
atomic<int>、atomic<long>等 - 指针:
atomic<int*> - 布尔:
atomic<bool> - 自定义类型(需满足某些条件)
原子变量支持的操作主要有:
load():原子读取store():原子写入exchange():原子交换(写入新值,返回旧值)compare_exchange_weak/strong:比较并交换(CAS)- 算术运算:
fetch_add、fetch_sub等 - 位运算:
fetch_and、fetch_or等
所有原子操作都保证原子性,但可见性和顺序性由内存序参数控制。
2.3 原子性的重要性:计数器示例
考虑一个简单的计数器累加场景:4个线程各执行500次counter++,预期结果2000。不同实现方式的对比:
| 实现方式 | 是否安全 | 结果 | 性能排序 |
|---|---|---|---|
| 普通int(无保护) | 不安全 | 随机(如1753) | 最快 |
| 互斥锁(std::mutex) | 安全 | 稳定2000 | 3 |
| 自旋锁(spinlock) | 安全 | 稳定2000 | 2 |
| 原子变量(std::atomic) | 安全 | 稳定2000 | 1 |
原子变量之所以性能最高,是因为它利用CPU硬件支持,避免了操作系统级别的线程挂起和唤醒。
#include <atomic>
#include <thread>
#include <vector>
std::atomic<int> counter(0);
void worker() {
for (int i = 0; i < 500; ++i) {
counter.fetch_add(1, std::memory_order_relaxed); // 原子加
}
}
int main() {
std::vector<std::thread> threads;
for (int i = 0; i < 4; ++i) threads.emplace_back(worker);
for (auto& t : threads) t.join();
// counter == 2000
}
三、原子性的硬件实现
要深入理解原子操作,必须了解CPU的存储体系结构和缓存一致性协议。
3.1 单核环境:中断屏蔽
在单核单处理器系统中,线程并发本质上是分时复用。原子性可以通过屏蔽中断来实现:在执行一系列指令时,禁止硬件中断,防止线程被调度出去。但这种方法只适用于单核,多核下无效。
3.2 多核环境:缓存一致性与总线锁定
多核系统中,每个核心有自己的缓存,可能导致数据不一致。例如:核心A修改了变量x,但修改仅停留在A的缓存中,核心B从内存读取的是旧值。
解决方案早期采用总线锁定:在执行原子操作时,CPU通过LOCK信号锁定总线,阻止其他核心访问内存。但这种方式会阻塞所有内存访问,效率低下。
现代CPU采用更细粒度的缓存一致性协议,如MESI,仅锁定涉及的内存区域(缓存行),允许其他核心并发访问无关内存。
3.3 存储体系结构与缓存
CPU与内存速度差距巨大,因此引入了多级缓存:
- L1缓存:核心独占,访问延迟约1ns
- L2缓存:核心独占,延迟约4ns
- L3缓存:多核共享,延迟约15ns
- 主存:延迟约80ns
缓存以缓存行(Cache Line)为单位,通常64字节。当CPU访问一个变量时,会将其所在的整个缓存行加载到缓存中。这带来了伪共享问题:多个线程修改位于同一缓存行的不同变量,会导致缓存行频繁失效,影响性能。
3.4 缓存一致性问题
多核系统中,每个核心的缓存可能保存同一内存地址的副本。当某个核心修改数据时,必须通知其他核心,否则它们会读到旧值。这需要缓存一致性协议。
3.5 MESI协议详解
MESI协议是最常见的缓存一致性协议,为每个缓存行维护四种状态:
- Modified (M):数据已被当前核心修改,与主存不一致,且该数据独占(其他核心无有效副本)。
- Exclusive (E):数据与主存一致,且仅存在于当前核心的缓存中。
- Shared (S):数据与主存一致,且存在于多个核心的缓存中。
- Invalid (I):该缓存行无效,需要从主存或其他核心获取最新数据。
状态转移依赖于核心本地请求(如读、写)和总线嗅探到的其他核心的操作。例如:
- 核心A想写一个处于E状态的行:直接转为M,无需通知总线。
- 核心A想写一个处于S状态的行:必须向总线发送“读独占”请求,其他核心收到后将其对应行置为I,然后A转为M。
- 核心A读一个I状态的行:发送总线读请求,若其他核心有M/E状态,则它必须先将数据写回主存,然后所有核心转为S。
原子操作的实现依赖于MESI协议:当执行原子读-改-写指令(如LOCK XADD)时,CPU会确保相应的缓存行处于E或M状态,并在修改期间阻止其他核心访问该行,从而实现操作的原子性。
四、内存序(Memory Order)
4.1 为什么需要内存序
原子操作保证了操作的原子性,但无法保证执行顺序和可见性。编译器优化和CPU乱序执行可能重排指令,导致多线程程序出现意料之外的结果。
例如:
std::atomic<int> x(0), y(0);
// 线程1
x.store(1); // 写x
int r1 = y.load(); // 读y
// 线程2
y.store(1);
int r2 = x.load();
在没有内存序约束时,可能发生r1=0且r2=0的情况,因为编译器可能将线程1的x.store和y.load重排,或者线程2的y.store和x.load重排。
可见性:一个核心的修改何时被其他核心看到?若不加控制,可能延迟。
4.2 内存序的作用
内存序参数用于指定原子操作所需的同步性和顺序性:
- 同步性:确保修改对其他线程立即可见。
- 顺序性:限制编译器和CPU对原子操作前后指令的重排。
C++11定义了六种内存序,常用的是以下四种:
4.3 常见内存序介绍
memory_order_relaxed
- 原子性:保证
- 同步性:无保证,其他线程可能看到旧值。
- 顺序性:无保证,允许编译器/CPU任意重排。
- 适用场景:仅需要原子性,对数据时效性无要求,如统计计数器(最终一致即可)。
memory_order_release 和 memory_order_acquire
这是一对用于同步的模型,通常配对使用。
- release:用于写操作(如store)。保证:
- 所有之前的读写操作(非原子或relaxed)都不会被重排到该release之后。
- 该写入对其他执行acquire的线程可见。
- acquire:用于读操作(如load)。保证:
- 所有之后的读写操作都不会被重排到该acquire之前。
- 能看到之前执行release的线程的所有写入。
典型用法:生产者-消费者。生产者用release写数据,消费者用acquire读数据,确保消费者看到完整的数据。
memory_order_acq_rel
用于读-修改-写操作(如exchange、compare_exchange)。同时具有acquire和release语义:读部分像acquire,写部分像release。
memory_order_seq_cst(默认)
最强约束,保证顺序一致性。所有使用seq_cst的原子操作在全局上有一个单一的全序,且禁止所有编译器和CPU重排。性能最差,但最容易理解。
4.4 内存序选择示例
考虑三个原子变量x、y、z,初始false。两个线程:
std::atomic<bool> x{false}, y{false}, z{false};
// 线程A
void write_x_y() {
x.store(true, std::memory_order_release);
y.store(true, std::memory_order_release);
}
// 线程B
void read_z() {
while (!y.load(std::memory_order_acquire));
if (x.load(std::memory_order_acquire)) {
z.store(true, std::memory_order_relaxed);
}
}
这里,线程A的release与线程B的acquire同步,保证了当B看到y为true时,也一定能看到x为true(如果A先写x后写y)。这是典型的同步模式。
若都用relaxed,则可能B看到y为true但x仍为false(由于重排)。
五、原子操作的应用
5.1 无锁数据结构简介
原子操作是实现无锁数据结构的基础。常见无锁结构包括:无锁栈、无锁队列、跳表等。它们通过CAS(compare-and-swap)操作来管理并发访问,避免锁的开销。
5.2 跳表中的原子操作
以RocksDB中的跳表实现为例,跳表节点包含多个指针,这些指针用std::atomic修饰,并使用不同的内存序以优化性能。
- 节点的高度信息使用
relaxed加载,因为跳表是概率性数据结构,即使读到旧高度也无妨。 - 节点指针的读取使用
acquire,写入使用release,以确保插入节点的正确可见性。
示例伪代码:
struct Node {
int key;
std::atomic<Node*> next[1]; // 实际可变长度
};
void insert(Node* new_node) {
Node* pred = find_predecessor(new_node->key);
new_node->next[0].store(pred->next[0].load(std::memory_order_relaxed),
std::memory_order_release);
while (!pred->next[0].compare_exchange_weak(
new_node->next[0].load(std::memory_order_relaxed),
new_node,
std::memory_order_release,
std::memory_order_relaxed)) {
// 重试
}
}
六、互斥锁的实现原理
互斥锁(mutex)是一种更高级的同步原语,其内部通常结合了原子操作、自旋锁和线程阻塞/唤醒机制。典型的实现包含:
- 原子标志:用一个原子变量表示锁是否被持有。
- 自旋等待:在用户态短暂自旋,尝试获取锁,以减少线程切换。
- 阻塞队列:如果自旋失败,线程进入内核态阻塞,并加入等待队列。
- 唤醒:解锁时,如果有等待线程,则唤醒一个。
大致流程:
lock():- 尝试用CAS将锁标志从0改为1,若成功则获得锁。
- 若失败,则进入自旋循环(可选次数)。
- 自旋仍失败,则线程挂起,并记录到等待队列。
unlock():- 原子地将锁标志置0。
- 检查是否有等待线程,若有则唤醒一个。
现代互斥锁实现还会考虑公平性(防止饥饿)、优先级继承等。

浙公网安备 33010602011771号