用 Rust 从零实现对象池:服务端为什么离不开 Arena
连接池、线程池、缓冲池、对象池——服务端到处都是"池"。
初学者容易把"池"理解成"提前分配好,省一次 malloc"。省一次分配当然有收益,但那是小头。池真正的价值是三个:控制上限、避免碎片、批量管理生命周期。
这篇从零写两个东西:一个泛型对象池,和一个只分配不单独释放的 Arena。
为什么不用系统分配器
先看一个典型的每请求分配场景:
fn handle(conn: &mut TcpStream) {
let buf = vec![0u8; 64 * 1024]; // 每个请求分配 64 KiB
// ... 处理 ...
} // 请求结束,buf 释放高 QPS 下,这段代码每秒会做上万次 64 KiB 的分配和释放。问题不在"malloc 慢"(现代 malloc 很快),而在于:
- 分配器要花时间找合适的块,尤其在多线程下还要处理锁
- 大小不一的分配释放会制造碎片
- 峰值内存不可控——并发一高,瞬时分配量直接打满
池化能同时缓解这三点。写之前先明确:池本质是用"复用"换取"分配次数下降"。
版本一:固定大小对象池
最简单的池:预先建好 N 个同类型对象,用一个空闲链表串起来。谁要谁拿走,用完还回来。
use std::cell::UnsafeCell;
use std::sync::atomic::{AtomicUsize, Ordering};
struct Slot<T> {
value: UnsafeCell<Option<T>>,
next: AtomicUsize, // 下一个空闲槽的下标,usize::MAX 表示链表结束
}
pub struct ObjectPool<T> {
slots: Box<[Slot<T>]>,
free_head: AtomicUsize,
}这里用下标而不是指针做链表。下标的好处是:整个池是一块连续内存,缓存友好,而且不用担心指针失效。
impl<T> ObjectPool<T> {
pub fn new(capacity: usize, mut factory: impl FnMut() -> T) -> Self {
let slots: Vec<Slot<T>> = (0..capacity)
.map(|i| Slot {
value: UnsafeCell::new(Some(factory())),
// 第 i 个槽指向第 i+1 个;最后一个指向结束
next: AtomicUsize::new(if i + 1 < capacity { i + 1 } else { usize::MAX }),
})
.collect();
Self {
slots: slots.into_boxed_slice(),
free_head: AtomicUsize::new(0),
}
}
}池的初始化阶段一次性建好所有对象,之后运行期不再做分配。 这一步就把"运行期碎片"这个变量彻底消掉了。
取出和归还,本质是对空闲链表的 pop 和 push:
pub fn acquire(&self) -> Option<PoolGuard<'_, T>> {
loop {
let head = self.free_head.load(Ordering::Acquire);
if head == usize::MAX {
return None; // 池空了
}
let next = self.slots[head].next.load(Ordering::Relaxed);
// CAS:只有没人抢走时才成功
if self
.free_head
.compare_exchange_weak(head, next, Ordering::AcqRel, Ordering::Acquire)
.is_ok()
{
return Some(PoolGuard { pool: self, idx: head });
}
// 失败了说明有人抢先,重试
}
}
fn release(&self, idx: usize) {
loop {
let head = self.free_head.load(Ordering::Acquire);
self.slots[idx].next.store(head, Ordering::Relaxed);
if self
.free_head
.compare_exchange_weak(head, idx, Ordering::AcqRel, Ordering::Acquire)
.is_ok()
{
return;
}
}
}这段是无锁的,但先别急着夸它——它只做链表操作,真正的对象访问仍然要外面保证不并发。无锁池的坑后面单独讲,这里先看懂 CAS 重试的结构。
RAII:让"用完归还"不会忘
如果 acquire 返回裸对象,调用方可能忘记归还,池就慢慢漏空了。Rust 的解法是 RAII guard——析构时自动归还。
pub struct PoolGuard<'a, T> {
pool: &'a ObjectPool<T>,
idx: usize,
}
impl<'a, T> std::ops::Deref for PoolGuard<'a, T> {
type Target = T;
fn deref(&self) -> &T {
unsafe { (*self.pool.slots[self.idx].value.get()).as_ref().unwrap() }
}
}
impl<'a, T> std::ops::DerefMut for PoolGuard<'a, T> {
fn deref_mut(&mut self) -> &mut T {
unsafe { (*self.pool.slots[self.idx].value.get()).as_mut().unwrap() }
}
}
impl<'a, T> Drop for PoolGuard<'a, T> {
fn drop(&mut self) {
self.pool.release(self.idx);
}
}有了 Drop,取用就像普通引用一样自然:
let mut obj = pool.acquire().expect("pool exhausted");
obj.reset(); // 用
// 作用域结束,自动归还RAII 是对象池在 Rust 里比在 C 里好写的地方:C 需要每个调用点记得 free,Rust 编译器帮你保证归还。
池耗尽:等待还是拒绝?
前面 acquire 池空时返回 None。但真实服务通常希望"等一会儿再拿"。加一个条件变量:
use std::sync::{Condvar, Mutex};
pub struct BlockingPool<T> {
inner: ObjectPool<T>,
lock: Mutex<()>,
available: Condvar,
}
impl<T> BlockingPool<T> {
pub fn acquire_timeout(&self, timeout: std::time::Duration) -> Option<PoolGuard<'_, T>> {
let mut guard = self.lock.lock().unwrap();
let deadline = std::time::Instant::now() + timeout;
loop {
if let Some(obj) = self.inner.acquire() {
return Some(obj);
}
let now = std::time::Instant::now();
if now >= deadline {
return None; // 超时,调用方决定是排队还是直接失败
}
let (g, _) = self.available.wait_timeout(guard, deadline - now).unwrap();
guard = g;
}
}
}超时是必须的。 一个没有超时的池,在依赖挂掉时会把所有请求线程全部堵死——这是非常典型的线上事故。
版本二:Arena——只分配,不单独释放
对象池管理的是"同一种对象"。但很多时候我们要的是"一次性分配一堆大小不一的临时数据,然后一起丢掉"。这就是 Arena。
Arena 的语义和 bump 分配器一样:只前进,不回收;但提供一个 reset 一次性清空。
pub struct Arena {
chunks: Vec<Vec<u8>>,
current: usize, // 当前 chunk 下标
offset: usize, // 当前 chunk 里的偏移
chunk_size: usize,
}
impl Arena {
pub fn new(chunk_size: usize) -> Self {
Self {
chunks: vec![vec![0u8; chunk_size]],
current: 0,
offset: 0,
chunk_size,
}
}
pub fn alloc_bytes(&mut self, size: usize, align: usize) -> &mut [u8] {
let aligned = (self.offset + align - 1) & !(align - 1);
if aligned + size > self.chunk_size {
// 当前 chunk 放不下,开新 chunk
self.chunks.push(vec![0u8; self.chunk_size.max(size)]);
self.current += 1;
self.offset = 0;
return self.alloc_bytes(size, align);
}
let start = aligned;
self.offset = aligned + size;
&mut self.chunks[self.current][start..start + size]
}
}Arena 的杀手锏是释放是 O(1) 的:
pub fn reset(&mut self) {
self.chunks.truncate(1);
self.current = 0;
self.offset = 0;
}一次调用释放全部。没有遍历,没有合并,没有碎片。
这非常适合这些场景:
| 场景 | 为什么适合 |
|---|---|
| 请求处理 | 一个请求的所有临时分配,请求结束全丢 |
| 编译/解析 | AST 节点生命周期一致,一起释放 |
| 批处理 | 每批独立,批结束重置 |
| 图/树结构 | 节点互相引用,用 arena 下标代替指针 |
最后一条特别值得展开。图结构用 Rc 会有引用计数开销和循环引用问题,用裸指针要自己管生命周期。Arena 给了第三条路:所有节点放在一起,节点之间用下标互相引用。
pub struct Graph {
arena: Arena,
nodes: Vec<NodeId>,
}
#[derive(Clone, Copy)]
pub struct NodeId(usize);
impl Graph {
pub fn add_node(&mut self, data: &[u8]) -> NodeId {
let id = self.nodes.len();
self.nodes.push(NodeId(id));
self.arena.alloc_bytes(data.len(), 8);
NodeId(id)
}
}下标即索引,Copy 且无生命周期纠缠。这也是很多 Rust 图库(petgraph 等)的核心设计。
池化的代价,别忽略
池不是免费的。引入它之前先问自己三个问题:
1. 对象真的有复用价值吗? 如果每次取出来都要 reset 一遍全部字段,省下的分配时间可能还不如重置时间。
2. 池的大小怎么定? 太小会耗尽排队,太大会占着内存不用。经验值是按 P99 并发数 + 一点余量。
3. 会不会掩盖内存泄漏? 对象一直存在于池里,如果程序没正确归还,池会静默枯竭,而不是像普通分配那样"释放就该回收"。池化会让某些 bug 变得更隐蔽。
结论
对象池和 Arena 是同一个思路的两种形态:
对象池管"同类型的复用",Arena 管"一批同生共死的分配"。前者靠空闲链表 + RAII,后者靠指针前进 + 整体重置。
它们的共同点是把零散的分配收拢成批量的、可预测的内存行为。服务端要的从来不是"最快的一次分配",而是"稳定可控的内存曲线"——这才是池存在的真正理由。