自定义全局分配器 ​

核心概念 ​

Rust 默认使用系统分配器(Windows 上是 HeapAlloc,Linux/macOS 上是 malloc/free)进行堆内存分配。通过 #[global_allocator] 属性,可以替换为自定义的全局分配器。自定义分配器需要实现 std::alloc::GlobalAlloc trait,提供 alloc 和 dealloc 两个核心方法。

替换全局分配器的常见原因包括:使用性能更好的分配器(如 jemalloc、mimalloc)、追踪内存使用情况、在嵌入式环境中使用定制的内存管理策略。

rust
// 使用 #[global_allocator] 替换全局分配器
// 这里展示的是概念性代码

use std::alloc::{GlobalAlloc, Layout};

// 自定义分配器结构体
struct MyAllocator;

// 实现 GlobalAlloc trait
unsafe impl GlobalAlloc for MyAllocator {
    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
        // 委托给系统分配器(实际项目中会使用更高效的实现)
        unsafe { std::alloc::System.alloc(layout) }
    }

    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
        unsafe { std::alloc::System.dealloc(ptr, layout) }
    }
}

// 注册为全局分配器
#[global_allocator]
static ALLOCATOR: MyAllocator = MyAllocator;

fn main() {
    // 所有堆分配(Vec, String, Box 等)都会通过 MyAllocator
    let v = vec![1, 2, 3];
    let s = String::from("hello");
    println!("{:?}, {}", v, s);
}

GlobalAlloc trait ​

rust
use std::alloc::{GlobalAlloc, Layout};

// GlobalAlloc 的完整定义
// unsafe trait GlobalAlloc {
//     unsafe fn alloc(&self, layout: Layout) -> *mut u8;
//     unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout);
//
//     // 可选方法(有默认实现)
//     unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8;
//     unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8;
// }

// Layout 描述了内存分配的需求
fn layout_examples() {
    // Layout 包含 size(大小)和 align(对齐)
    let layout = Layout::new::<u64>();
    println!("u64: size={}, align={}", layout.size(), layout.align());

    let layout = Layout::new::<[u8; 100]>();
    println!("[u8; 100]: size={}, align={}", layout.size(), layout.align());

    // 从大小和对齐创建
    let layout = Layout::from_size_align(1024, 8).unwrap();
    println!("自定义: size={}, align={}", layout.size(), layout.align());
}

fn main() {
    layout_examples();
}
方法说明必须实现
alloc分配内存是
dealloc释放内存是
alloc_zeroed分配并清零否(有默认实现)
realloc重新分配否(有默认实现)

使用第三方分配器 ​

toml
# Cargo.toml

# === mimalloc(微软开发,高性能)===
[dependencies]
mimalloc = "0.1"

# === jemalloc(FreeBSD 默认分配器)===
# [dependencies]
# tikv-jemallocator = "0.6"

# === 仅在特定平台使用 ===
# [target.'cfg(not(target_env = "msvc"))'.dependencies]
# tikv-jemallocator = "0.6"
rust
// 使用 mimalloc 分配器
use mimalloc::MiMalloc;

#[global_allocator]
static GLOBAL: MiMalloc = MiMalloc;

fn main() {
    // 所有堆分配现在使用 mimalloc
    let mut data = Vec::with_capacity(1000);
    for i in 0..1000 {
        data.push(i);
    }
    println!("使用 mimalloc 分配了 {} 个元素", data.len());
}
rust
// 使用 jemalloc 分配器(非 Windows)
// use tikv_jemallocator::Jemalloc;
//
// #[global_allocator]
// static GLOBAL: Jemalloc = Jemalloc;
//
// fn main() {
//     let s = String::from("使用 jemalloc");
//     println!("{}", s);
// }

fn main() {
    println!("jemalloc 适合多线程高并发场景");
}

内存追踪分配器 ​

rust
use std::alloc::{GlobalAlloc, Layout, System};
use std::sync::atomic::{AtomicUsize, Ordering};

// 追踪内存分配的分配器
struct TrackingAllocator {
    allocated: AtomicUsize,
    deallocated: AtomicUsize,
    allocation_count: AtomicUsize,
}

unsafe impl GlobalAlloc for TrackingAllocator {
    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
        // 记录分配
        self.allocated.fetch_add(layout.size(), Ordering::Relaxed);
        self.allocation_count.fetch_add(1, Ordering::Relaxed);
        // 委托给系统分配器
        unsafe { System.alloc(layout) }
    }

    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
        // 记录释放
        self.deallocated.fetch_add(layout.size(), Ordering::Relaxed);
        unsafe { System.dealloc(ptr, layout) }
    }
}

#[global_allocator]
static TRACKER: TrackingAllocator = TrackingAllocator {
    allocated: AtomicUsize::new(0),
    deallocated: AtomicUsize::new(0),
    allocation_count: AtomicUsize::new(0),
};

fn main() {
    // 使用堆分配
    let v: Vec<i32> = (0..100).collect();
    let s = String::from("hello, allocator tracking!");
    let b = Box::new(42);

    println!("向量长度: {}", v.len());
    println!("字符串: {}", s);
    println!("Box: {}", b);

    // 查看内存统计
    println!("\n--- 内存统计 ---");
    println!(
        "总分配: {} 字节",
        TRACKER.allocated.load(Ordering::Relaxed)
    );
    println!(
        "总释放: {} 字节",
        TRACKER.deallocated.load(Ordering::Relaxed)
    );
    println!(
        "当前使用: {} 字节",
        TRACKER.allocated.load(Ordering::Relaxed)
            - TRACKER.deallocated.load(Ordering::Relaxed)
    );
    println!(
        "分配次数: {}",
        TRACKER.allocation_count.load(Ordering::Relaxed)
    );
}

基本示例 ​

toml
# Cargo.toml
[package]
name = "allocator-demo"
version = "0.1.0"
edition = "2024"

[dependencies]
mimalloc = "0.1"
rust
// 生产项目中使用 mimalloc
use mimalloc::MiMalloc;

#[global_allocator]
static GLOBAL: MiMalloc = MiMalloc;

fn benchmark_allocations() {
    let start = std::time::Instant::now();

    // 大量小对象分配
    let mut vecs: Vec<Vec<u8>> = Vec::new();
    for i in 0..10000 {
        vecs.push(vec![0u8; i % 256]);
    }

    // 释放
    drop(vecs);

    let elapsed = start.elapsed();
    println!("分配和释放 10000 个 Vec 耗时: {:?}", elapsed);
}

fn main() {
    benchmark_allocations();
    println!("全局分配器: mimalloc");
}

常见问题 ​

问题一:替换全局分配器对性能有多大影响?

取决于工作负载。对于多线程高并发场景,jemalloc 和 mimalloc 比系统分配器快 10-30%。对于单线程简单应用,差异可能不明显。

问题二:mimalloc 和 jemalloc 怎么选?

mimalloc 启动更快、内存占用更低,适合一般用途。jemalloc 在极端多线程场景下表现更好,适合高并发服务器。两者都比默认系统分配器表现好。

问题三:全局分配器可以在运行时切换吗?

不能。#[global_allocator] 是编译时决定的,整个程序生命周期使用同一个分配器。如果需要局部使用不同分配器,可以用 Allocator API(不稳定)。

问题四:no_std 环境怎么设置分配器?

在 no_std + alloc 环境中,必须提供 #[global_allocator],因为没有系统分配器。通常使用嵌入式专用的分配器(如 embedded-alloc)。

适用场景 ​

  • 高性能服务器:jemalloc/mimalloc 提升分配性能
  • 内存调试:追踪分配和泄漏
  • 嵌入式系统:自定义内存管理策略
  • 性能分析:统计内存使用模式

注意事项 ​

  • #[global_allocator] 只能使用一次
  • GlobalAlloc 的方法是 unsafe 的
  • 分配器必须是线程安全的
  • 不能在运行时切换全局分配器
  • jemalloc 在 Windows MSVC 上不可用
  • 分配器错误(如双重释放)是未定义行为

总结 ​

#[global_allocator] 允许替换 Rust 的默认堆内存分配器。自定义分配器需要实现 GlobalAlloc trait 的 alloc 和 dealloc 方法。常用的第三方分配器有 mimalloc(通用高性能)和 jemalloc(多线程优化)。追踪分配器可以统计内存使用情况,帮助发现内存问题。全局分配器在编译时确定,不能运行时切换。no_std 环境必须提供自定义分配器。分配器必须是线程安全的,实现错误会导致未定义行为。