
在现代高性能存储引擎(如 RocksDB、BadgerDB 及各类内存数据库)的设计中,跳表(SkipList)是构建写缓冲区(MemTable)的绝对核心数据结构。相比于红黑树、AVL 树等自平衡二叉搜索树,跳表通过概率分层机制将平衡维系成本分摊到了随机数生成上,从而规避了极其复杂的树旋转操作,这使得它天然成为并发无锁化改造的最佳载体。
然而,在多核处理器体系结构中,实现一个真正高吞吐且绝对内存安全的**并发无锁跳表(Lock-Free SkipList)**是一项极具挑战性的系统级工程。
其最核心的凶险之处在于:现代 CPU(特别是 ARM64、RISC-V 等弱内存模型架构)以及现代编译器,会在不破坏单线程依赖语义的前提下对内存读写进行激进的指令重排(Memory Reordering)。
如果你在向多层链表中原子接入一个新节点时,仅仅使用朴素的原子指针交换,其他 CPU 核心极有可能在读取到新节点的地址指针时,该节点内部的键值对内容尚未从当前核心的 Store Buffer 刷入 L1/L2 缓存,从而读出充斥着垃圾数据的幽灵节点,引发系统静默数据破坏或空指针崩溃。
本文将以 Rust 为武器,深入剖析并发跳表的底层原理,并基于 AtomicPtr 与精确的 Acquire-Release 内存屏障语义,构建一套能够抵御硬件乱序执行的安全指针发布范式。
硬件乱序与“不安全指针发布”的微架构死穴
设想一个工作线程要在跳表的第一层(Level 0)插入一个新节点 Node { key: 42, val: 100, next: AtomicPtr }。整个操作在高级语言中看似只有简单的两步:
- 在堆上分配内存并初始化节点字段;
- 将前驱节点的
next指针原子替换为指向新节点的指针。
但在硬件微架构层面的时间线上,事情往往是这样的:
[核心 A (写入者)] [核心 B (并发读取者)]
1. 分配 Node 内存 (地址 0x8000)
2. 写入 node.key = 42 (留在 Store Buffer)
3. 写入 node.val = 100 (留在 Store Buffer)
4. 将 prev.next 原子更新为 0x8000
5. 读取 prev.next -> 得到 0x8000
6. 解引用 0x8000.key -> 💥 读出未初始化的垃圾值 0!
7. Store Buffer 终于刷入缓存行...
在弱内存模型架构(如 ARMv8)下,CPU 甚至可能先将更新后的指针广播出去,再刷入节点的数据字段。这就是典型的安全发布(Safe Publication)破坏。
在 Rust 中,要彻底切断这种跨核乱序,必须严格依赖 Atomic Ordering 建立的 Synchronizes-with(同步于) 语义关系:
- 写入端使用
Ordering::Release:强制形成一道内存屏障,确保在当前 Release 写指令之前发生的所有普通内存写入(包括节点的内存分配和数据赋值),对后续任何以 Acquire 语义读取该原子变量的 CPU 核心立即可见,严禁任何指令重排到底部; - 读取端使用
Ordering::Acquire:强制形成读取屏障,确保在当前 Acquire 读指令之后发生的所有内存读取,严禁重排到该读取指令之前,从而保证读出的裸指针所指的数据绝对是完全初始化好的状态。
跳表节点与原子层级结构设计
为了实现多层级的高并发跳跃,每个跳表节点必须维护一个变长的原子后继指针数组。在 Rust 中,我们采用紧凑的内存布局:
use std::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
use std::ptr;
use std::alloc::{alloc, dealloc, Layout};
pub const MAX_LEVEL: usize = 16;
pub struct SkipNode<K, V> {
pub key: K,
pub value: V,
pub height: usize,
// 柔性数组指针:保存当前节点在每一层的后继原子指针
pub next: [AtomicPtr<SkipNode<K, V>>; MAX_LEVEL],
}
impl<K, V> SkipNode<K, V> {
pub fn new(key: K, value: V, height: usize) -> *mut Self {
assert!(height > 0 && height <= MAX_LEVEL);
let node = Box::into_raw(Box::new(Self {
key,
value,
height,
next: Default::default(),
}));
node
}
}
核心并发算法:安全的自旋 CAS 与多层链接发布
并发跳表的插入分为两个核心阶段:
- 寻找前驱(Find Predecessors):从最高层向下逐层扫描,找到每一层中键小于目标键的最大节点,记录其裸指针;
- 底层推进与逐层发布:先在最底层的 Level 0 通过 CAS(Compare-And-Swap)将新节点接入链表。一旦 Level 0 成功接入,该节点在逻辑上就已经对全网查询生效;随后自底向上逐层更新高层索引。
pub struct ConcurrentSkipList<K: Ord, V> {
head: *mut SkipNode<K, V>,
max_height: AtomicUsize,
}
impl<K: Ord + Clone, V: Clone> ConcurrentSkipList<K, V> {
pub fn new(dummy_key: K, dummy_val: V) -> Self {
let head = SkipNode::new(dummy_key, dummy_val, MAX_LEVEL);
Self {
head,
max_height: AtomicUsize::new(1),
}
}
/// 在全网并发读取时查找特定键对应的值
pub fn get(&self, key: &K) -> Option<V> {
let mut curr = self.head;
let mut level = self.max_height.load(Ordering::Acquire);
while level > 0 {
level -= 1;
loop {
// 核心点 1:以 Acquire 语义读取后继指针,防止读取重排
let next_ptr = unsafe { (*curr).next[level].load(Ordering::Acquire) };
if next_ptr.is_null() {
break;
}
let next_node = unsafe { &*next_ptr };
if &next_node.key < key {
curr = next_ptr;
} else if &next_node.key == key {
// 找到目标节点,由于前驱是指向它的 Acquire 读,其 value 绝对初始化完成
return Some(next_node.value.clone());
} else {
// next_node.key > key,进入下一层下降
break;
}
}
}
None
}
/// 并发插入新节点
pub fn insert(&self, key: K, value: V, height: usize) -> bool {
let mut preds = [ptr::null_mut(); MAX_LEVEL];
let mut succs = [ptr::null_mut(); MAX_LEVEL];
loop {
// 1. 寻找每一层的前驱和后继
let mut curr = self.head;
let current_max = self.max_height.load(Ordering::Acquire);
let mut level = current_max.max(height);
while level > 0 {
level -= 1;
loop {
let next_ptr = unsafe { (*curr).next[level].load(Ordering::Acquire) };
if next_ptr.is_null() {
preds[level] = curr;
succs[level] = ptr::null_mut();
break;
}
let next_node = unsafe { &*next_ptr };
if next_node.key < key {
curr = next_ptr;
} else if next_node.key == key {
// 键已存在,本简化模型中直接返回 false
return false;
} else {
preds[level] = curr;
succs[level] = next_ptr;
break;
}
}
}
// 2. 创建准备插入的新节点
let new_node = SkipNode::new(key.clone(), value.clone(), height);
// 将新节点的各层后继指针先行初始化为预测的 succs
for i in 0..height {
unsafe {
(*new_node).next[i].store(succs[i], Ordering::Relaxed);
}
}
// 3. 核心决战:在 Level 0 进行原子 CAS 操作
// 必须使用 Release 确保 new_node 内部的所有数据完全对全核可见!
let pred_level0 = preds[0];
let expected = succs[0];
let cas_result = unsafe {
(*pred_level0).next[0].compare_exchange(
expected,
new_node,
Ordering::Release, // 成功时:Release 内存屏障
Ordering::Relaxed, // 失败时:Relaxed,准备重试
)
};
match cas_result {
Ok(_) => {
// Level 0 插入成功!该节点在逻辑上已经正式发布
// 4. 自底向上原子补齐更高层的索引指针
for i in 1..height {
loop {
let pred = preds[i];
let succ = succs[i];
unsafe {
(*new_node).next[i].store(succ, Ordering::Relaxed);
if (*pred).next[i].compare_exchange(
succ,
new_node,
Ordering::Release,
Ordering::Relaxed,
).is_ok() {
break;
}
}
// 若高层 CAS 失败,只需简单刷新该层局部前驱并重试,不影响 Level 0 的存在性
break;
}
}
// 动态提升跳表最大层高
let mut old_h = self.max_height.load(Ordering::Relaxed);
while height > old_h {
if self.max_height.compare_exchange_weak(
old_h,
height,
Ordering::Release,
Ordering::Relaxed,
).is_ok() {
break;
}
old_h = self.max_height.load(Ordering::Relaxed);
}
return true;
}
Err(_) => {
// Level 0 发生冲突被其他线程抢先插入,销毁当前临时节点并自旋重试
unsafe {
let _ = Box::from_raw(new_node);
}
continue;
}
}
}
}
}
为什么 Release 与 Acquire 的配对能够绝对斩断硬件重排?
在上述代码中,有两处最为关键的屏障语义锚点:
compare_exchange成功分支的Ordering::Release:
在 x86 体系下,由于硬件是强内存模型(TSO),普通 Store 不会与前面的 Store 重排,Release 屏障在机器汇编上几乎是零成本的普通lock cmpxchg;但在 ARM64/Apple Silicon 架构下,编译器会精准发射一条stlr(Store-Release Register)指令。该指令在硬件流水线中坚决禁止任何之前的内存写操作滑移到它之后;get和find中的load(Ordering::Acquire):
在 ARM64 架构下,编译器会发射一条ldar(Load-Acquire Register)指令,严格禁止后续读取(如读取next_node.key)滑移到它之前。
这组配对在 CPU 核心之间建立了一条数学上确凿无疑的 Happens-Before 因果序:
$$\text{初始化 new_node 内存} \xrightarrow{\text{hb}} \text{CAS(Release 发布指针)} \xrightarrow{\text{sync-with}} \text{Load(Acquire 捕获指针)} \xrightarrow{\text{hb}} \text{解引用读取数据}$$
任何读取线程一旦通过 Acquire 观察到了新指针,就在物理硬件层面上百分之百保证能看到该节点内已经写好的 key 与 value。
结语
在构建极致吞吐的现代并发数据结构时,不能把希望寄托在“运气”或“我的机器是 x86 所以没报错”这种侥幸心理上。真正的系统级架构师,必须深入到跨核缓存一致性协议(MESI)与硬件指令乱序的深水区。
通过对 Atomic Ordering 细粒度的推导,把锁消除掉,把互斥变成无阻碍的 CAS,同时用严密的内存屏障筑起防线——这正是 Rust 无畏并发(Fearless Concurrency)最动人心魄的技术魅力所在。
1242



被折叠的 条评论
为什么被折叠?



