
在并发编程的世界里,队列(Queue)是连接不同计算阶段的最核心通道。
根据并发两端的角色,队列通常被划分为四种模型:
- SPSC(单生产者单消费者):最简单,只需两个原子指针分别由两端独立推进,完全不需要 CAS;
- MPSC / SPMC(单端竞争):中等难度,只需在一端通过 CAS 或链表头插法竞争;
- MPMC(多生产者多消费者):并发编程的珠穆朗玛峰。多个生产者不仅要互相抢占写入槽位,还要与多个并发消费的消费者进行实时的空间状态协商。
在 Rust 工业级生态中,crossbeam-channel 的底层核心就是这样一个极其精密的有界 MPMC 无锁队列。它在 Linux 下支撑起了每秒上千万条消息的微秒级流转。
许多人以为实现无锁队列就是拿一个 AtomicPtr 连成链表(类似经典的 Michael-Scott 队列)。但在现代高吞吐场景下,链表方案几乎是灾难:每个节点进出都要触发一次 Box::new 堆分配,链表指针在内存中到处跳跃导致 CPU 缓存频繁失效,而且在释放节点指针时还会一头撞上臭名昭著的 ABA 内存复用陷阱。
今天,我们采用高并发大师 Dmitry Vyukov 提出的经典定长环形缓冲区(Bounded Ring Buffer)架构,从零手写一个零堆分配、缓存连续、基于插槽单调递增序号(Sequence)消除 ABA 隐患的 Rust 原生无锁 MPMC 队列核心底座。
一、为什么环形数组 + 序号能终结 ABA 陷阱?
在无锁编程中,ABA 问题是指:线程 1 观察到指针值为 A,准备执行 CAS 操作;此时线程 2 快速将指针改为 B,又改回为 A;当线程 1 再次执行 CAS 时,虽然发现值依然是 A 并成功替换,但背后的实际数据结构可能已经面目全非(例如原节点已被释放并重新分配)。
要解决 ABA 问题,学术界通常采用危险指针(Hazard Pointer)或代际计数器(Epoch-based Reclamation),但它们都引入了不菲的运行时管理开销。
而在定长环形数组中,我们可以使用极其优雅的**插槽单调自增序号(Slot Sequence)**方案:
- 预先分配一块容量为 $N$ 的连续数组($N$ 通常为 2 的幂次方);
- 每一个插槽内部不仅保存数据,还内嵌一个专属的
AtomicUsize sequence序号; - 数组初始化时,第 $i$ 个插槽的
sequence被初始赋为 $i$; - 当生产者准备向该插槽写入第 1 轮数据时,它必须要求插槽当前的
sequence必须恰好等于预期值;写入完成后,它把sequence推进到特定值; - 消费者读取完毕后,再把
sequence推进一个步长,为下一轮循环的生产者放行。
由于序号永远沿着单调递增的生命周期旋转,同一个插槽在不同的业务轮次中永远拥有独一无二的序号状态,从而在数学逻辑上彻底消灭了 ABA 状态倒退的可能性!
二、核心插槽与环形队列的数据结构定义
我们首先定义包含数据槽位与原子序号的单插槽结构 Slot<T>:
use std::cell::UnsafeCell;
use std::mem::MaybeUninit;
use std::sync::atomic::{AtomicUsize, Ordering};
/// 队列中的单个插槽
struct Slot<T> {
/// 状态控制序号(必须是原子变量)
sequence: AtomicUsize,
/// 存储未初始化或有效数据的裸内存槽位
value: UnsafeCell<MaybeUninit<T>>,
}
// 保证 Slot 可以在线程间安全共享引用的约束
unsafe impl<T: Send> Sync for Slot<T> {}
紧接着,我们定义环形队列的主结构体 MpmcRingQueue<T>。
为了最大化 CPU 缓存友好度并规避伪共享(False Sharing),生产者游标 head 与消费者游标 tail 必须进行严谨的物理隔离:
use std::sync::Arc;
/// 缓存行填充包装器,防止 head 和 tail 挤在同一个 64 字节 Cache Line 内
#[repr(align(64))]
struct CachePadded<T> {
value: T,
}
impl<T> CachePadded<T> {
fn new(value: T) -> Self {
Self { value }
}
}
impl<T> std::ops::Deref for CachePadded<T> {
type Target = T;
fn deref(&self) -> &T {
&self.value
}
}
pub struct MpmcRingQueue<T> {
/// 预分配的连续插槽缓冲区
buffer: Box<[Slot<T>]>,
/// 掩码(容量 - 1),用于快速位运算取模:index = pos & mask
mask: usize,
/// 生产者写入游标(严格对齐到独立缓存行)
head: CachePadded<AtomicUsize>,
/// 消费者读取游标(严格对齐到独立缓存行)
tail: CachePadded<AtomicUsize>,
}
unsafe impl<T: Send> Send for MpmcRingQueue<T> {}
unsafe impl<T: Send> Sync for MpmcRingQueue<T> {}
三、插槽序号状态转移方程推导
这是整个无锁算法最惊心动魄的数学核心。
假设队列容量为 $C = 4$(掩码为 $C - 1 = 3$),初始状态下:
- 插槽 0 的 sequence = 0
- 插槽 1 的 sequence = 1
- 插槽 2 的 sequence = 2
- 插槽 3 的 sequence = 3
head= 0,tail= 0
写入端(Producer)的状态演进法则:
- 生产者读取全局游标
head,假设当前拿到位置 $pos = 0$; - 目标插槽索引为 $index = pos \ & \ mask = 0$;
- 可写条件:读取插槽 0 的当前序号 $seq$。只有当 $seq == pos$ 时,说明该插槽处于“空闲可写状态”;
- 生产者通过 CAS 尝试将全局
head从 $pos$ 推进到 $pos + 1$;- CAS 成功:说明当前生产者正式夺得了该插槽的独占写入权!
- CAS 失败:说明其他并发生产者抢先一步,当前生产者重新循环重试;
- 独占写入:生产者向插槽内部的
UnsafeCell安全写入数据; - 发布数据:生产者将该插槽的序号原子更新为 $pos + 1$(使用
Release内存屏障)!
读取端(Consumer)的状态演进法则:
- 消费者读取全局游标
tail,假设当前拿到位置 $pos = 0$; - 目标插槽索引为 $index = pos \ & \ mask = 0$;
- 可读条件:读取插槽 0 的当前序号 $seq$。只有当 $seq == pos + 1$ 时,说明生产者已经完整写入了数据!
- 消费者通过 CAS 尝试将全局
tail从 $pos$ 推进到 $pos + 1$;- CAS 成功:夺得独占读取权!
- CAS 失败:重新重试;
- 独占读取:消费者从
UnsafeCell取出数据; - 归还插槽:消费者将该插槽的序号原子更新为 $pos + C$($pos + \text{capacity}$,同样使用
Release屏障)!
注意看第 6 步:插槽 0 的序号从 1 被更新为了 $0 + 4 = 4$。
当下一轮生产者转了一整圈重新来到位置 $pos = 4$ 时,它要求的可写条件正是 $seq == pos$(即 $4 == 4$)!
整个生命周期构成了一条完美的、永不逆流的单调递增时空链!
四、队列初始化构造代码实现
在构造队列时,我们强制要求容量必须是 2 的幂次方,以便将昂贵的硬件除法取模(% capacity)替换为纳秒级的位与操作(& mask):
impl<T> MpmcRingQueue<T> {
/// 创建指定容量的无锁队列(容量必须为 2 的幂,且大于 1)
pub fn new(capacity: usize) -> Self {
assert!(capacity >= 2, "队列容量必须大于等于 2");
assert!(capacity.is_power_of_two(), "队列容量必须为 2 的幂次方(如 64, 256, 1024)");
// 预分配连续切片并初始化各个插槽的 sequence 序号
let mut slots = Vec::with_capacity(capacity);
for i in 0..capacity {
slots.push(Slot {
sequence: AtomicUsize::new(i),
value: UnsafeCell::new(MaybeUninit::uninit()),
});
}
Self {
buffer: slots.into_boxed_slice(),
mask: capacity - 1,
head: CachePadded::new(AtomicUsize::new(0)),
tail: CachePadded::new(AtomicUsize::new(0)),
}
}
/// 获取队列总容量
#[inline(always)]
pub fn capacity(&self) -> usize {
self.mask + 1
}
}
五、阶段性设计审视
到目前为止,我们已经搭建好了 MPMC 队列最坚不可摧的骨架:
- 内存连续无碎片:所有插槽在初始化阶段一次性分配完毕,后续入队出队完全没有任何
malloc系统调用; - 物理防伪共享:通过
#[repr(align(64))]让高频被生产者修改的head和被消费者修改的tail坐落在完全隔离的硬件缓存行上; - 状态自洽与代际隔离:每个插槽的单调序号机制在数学层面对抗了 ABA 幽灵。
在明天的下篇中,我们将手写最核心的 push 和 pop 算法,推导 Acquire-Release 内存屏障的严密逻辑,并在多核服务器上与标准库 channel 展开最终的性能对决!
1332



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



