返回文章列表

用 Rust 从零实现对象池:服务端为什么离不开 Arena

337 字·3 分钟阅读
Rust从零造轮子内存

连接池、线程池、缓冲池、对象池——服务端到处都是"池"。

初学者容易把"池"理解成"提前分配好,省一次 malloc"。省一次分配当然有收益,但那是小头。池真正的价值是三个:控制上限、避免碎片、批量管理生命周期。

这篇从零写两个东西:一个泛型对象池,和一个只分配不单独释放的 Arena。


为什么不用系统分配器

先看一个典型的每请求分配场景:

fn handle(conn: &mut TcpStream) {
    let buf = vec![0u8; 64 * 1024]; // 每个请求分配 64 KiB
    // ... 处理 ...
} // 请求结束,buf 释放

高 QPS 下,这段代码每秒会做上万次 64 KiB 的分配和释放。问题不在"malloc 慢"(现代 malloc 很快),而在于:

  1. 分配器要花时间找合适的块,尤其在多线程下还要处理锁
  2. 大小不一的分配释放会制造碎片
  3. 峰值内存不可控——并发一高,瞬时分配量直接打满

池化能同时缓解这三点。写之前先明确:池本质是用"复用"换取"分配次数下降"。

版本一:固定大小对象池

最简单的池:预先建好 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,后者靠指针前进 + 整体重置。

它们的共同点是把零散的分配收拢成批量的、可预测的内存行为。服务端要的从来不是"最快的一次分配",而是"稳定可控的内存曲线"——这才是池存在的真正理由。