分配器（Allocator）与自定义内存管理 on Dorkytiger 的小屋

一、容器为什么不直接 new/delete？

Mon, 01 Jan 0001 00:00:00 +0000

直接 new/delete 的问题：

// 假如 vector 内部用 new[]/delete[] 管理内存
// 那么每次 push_back 导致扩容时：
// ① new[] 分配新内存 + 默认构造 N 个元素（浪费！其实我只想申请内存，不构造）
// ② 拷贝/移动旧元素
// ③ delete[] 旧内存 + 析构所有元素（又浪费！其实我只想释放内存，不析构）

分配器把"分配内存"和"构造对象"分开了：

// vector 底层实际做的
Alloc alloc;
T* p = alloc.allocate(10);    // 只分配 10 个 T 大小的空间，不构造
// 这 10 个位置是原始内存，里面可能放着旧数据

alloc.construct(p + 3, args); // 在第 4 个位置构造一个新对象（placement new）
// 现在 p+3 才真正有了一个 T 对象

alloc.destroy(p + 3);         // 手动调用析构
alloc.deallocate(p, 10);      // 只释放内存，不析构

分离的意义：

reserve：只 allocate，不 construct——所以 reserve 快。
pop_back：只 destroy，不 deallocate——所以 pop_back 快。
自定义分配器只需重写 allocate/deallocate，construct/destroy 有默认行为。

二、Arena 分配器——最快的分配器

Mon, 01 Jan 0001 00:00:00 +0000

解决什么问题？

问题：游戏的一帧中需要频繁创建和销毁大量小对象。每次 new/delete 调用 malloc，而 malloc 内部用红黑树管理空闲块，有锁竞争，要几十纳秒甚至几微秒。

Arena 的思路：一次性批一大块内存，分配时只做指针加法（1-2 纳秒），释放时整块一起释放。

原理

class Arena {
    char* buffer_;
    size_t offset_ = 0;  // 当前分配到的位置
    size_t size_;

public:
    Arena(char* buf, size_t sz) : buffer_(buf), size_(sz) {}

    void* alloc(size_t bytes) {
        if (offset_ + bytes > size_) throw std::bad_alloc();
        void* ptr = buffer_ + offset_;
        offset_ += bytes;
        return ptr;
        // 这就是全部了！一条加法指令，约 1ns
    }

    void reset() { offset_ = 0; }  // 整块重置，不用逐个 delete
    // 没有 deallocate 方法——Arena 不支持单个释放
};

使用 Arena 的 vector 分配速度：

三、PMR（多态分配器）——C++17 的标准方案

Mon, 01 Jan 0001 00:00:00 +0000

你不需要手写分配器——标准库给你了

#include <memory_resource>

// 1. 分配一个缓冲区（可以栈上，可以堆上）
char buffer[1024 * 1024];  // 1MB

// 2. 创建 monotonic_buffer_resource（就是上面的 Arena）
std::pmr::monotonic_buffer_resource pool(buffer, sizeof(buffer));

// 3. 创建 pmr::vector，指定使用 pool
std::pmr::vector<int> vec(&pool);
vec.reserve(100000);  // 从 pool 分配，不调用 malloc

// 4. pool 析构时自动释放整个 buffer

PMR 提供的三种 Resource

Resource	行为	适用场景
`monotonic_buffer_resource`	只加偏移，不释放单个对象，整块释放	同 Arena，几乎最快
`unsynchronized_pool_resource`	对象池，管理不同大小的块，可释放单个	需要频繁 alloc/dealloc 相同大小的对象（单线程）
`synchronized_pool_resource`	同上，但线程安全	多线程共享同一个分配器

实战：用 PMR 优化日志处理

// 场景：HTTP 请求处理，每次请求需要构建大量 string
// 每次请求结束后，这些 string 全部可以释放

struct RequestContext {
    std::pmr::string method;
    std::pmr::string path;
    std::pmr::vector<std::pmr::string> headers;
    std::pmr::string body;
    // 所有 pmr::string 使用同一个 pool

    explicit RequestContext(std::pmr::memory_resource* pool)
        : method(pool), path(pool), headers(pool), body(pool) {}
};

// 每次请求创建一个 arena
char buffer[1024 * 64]; // 64KB 足够一次请求
std::pmr::monotonic_buffer_resource pool(buffer, sizeof(buffer));
RequestContext ctx(&pool);
// ... 处理请求 ...
// ctx 析构时，pool 复位，64KB 零碎分配一次性释放

四、第八阶段总结

Mon, 01 Jan 0001 00:00:00 +0000

分配器的本质：
    把 "分配内存" 和 "构造对象" 分离
    让 reserve 只分配不构造、pop_back 只析构不释放

Arena（monotonic_buffer_resource）：
    分配：指针加偏移（2ns）
    释放：整块释放（不逐个 delete）
    适用：生命周期整齐、高频分配的场景

PMR 的三种 resource：
    monotonic：纯 Arena，最快
    unsynchronized_pool：可释放单个
    synchronized_pool：线程安全版

价值：高频小对象场景加速 10-50 倍