第4章内存优化

内存优化：紧凑数据结构设计、内存池与对象复用、避免GC

内存优化这事儿，说白了就是跟内存分配器斗智斗勇。我做了这么多年低延迟系统，发现一个规律：内存访问模式决定了性能上限。订单簿重建这种高频操作，内存布局稍微不合理，延迟就能翻几倍。

今天咱们重点聊三个方向：紧凑数据结构、内存池与对象复用、以及GC的坑。嗯，Python和C++我都会对比着讲，毕竟很多团队是混用的。

紧凑数据结构设计

先问个问题：一个订单对象，你猜它占多少内存？

很多人随手写个类，十几个字段一摆，内存占用轻松上百字节。但你知道吗？缓存行只有64字节。一个对象跨两个缓存行，访问一次就要等两次内存读取。

我个人习惯的做法是：按访问频率重新排列字段。

// 不推荐：字段随意排列
struct Order {
    uint64_t order_id;
    double price;
    uint32_t volume;
    uint64_t timestamp;
    uint8_t side;      // 0=buy, 1=sell
    uint8_t status;    // 0=active, 1=cancelled
    // 实际占用：8+8+4+8+1+1 = 30字节，但对齐后是40字节
};

// 推荐：按访问频率和大小重新排列
struct alignas(64) Order {
    // 高频访问字段放前面
    double price;       // 8字节
    uint64_t order_id;  // 8字节
    uint32_t volume;    // 4字节
    uint64_t timestamp; // 8字节
    uint8_t side;       // 1字节
    uint8_t status;     // 1字节
    // 填充到64字节对齐
    uint8_t padding[34];
};

我在项目中遇到过一个问题：订单簿重建时，大量订单对象散落在内存各处，导致缓存命中率极低。后来改成结构体数组（SoA），性能直接提升了30%。

核心原则：把同一时间访问的字段放在同一个缓存行内。说白了就是「物以类聚」——价格和数量经常一起读，那就挨着放。

Python这边呢？嗯，情况更棘手。Python对象本身就有开销——每个对象至少56字节（PyObject_HEAD）。你想想看，一个简单的订单对象，Python可能要占200+字节。

# Python中可以用__slots__减少内存
class Order:
    __slots__ = ('price', 'order_id', 'volume', 'side')
    
    def __init__(self, price, order_id, volume, side):
        self.price = price
        self.order_id = order_id
        self.volume = volume
        self.side = side

用了__slots__之后，每个对象能省下约40%的内存。但说实话，Python做高频交易还是有点勉强。我一般建议：Python只做策略逻辑，底层数据用C++扩展。

内存池与对象复用

动态内存分配是延迟杀手。每次new/delete或者malloc/free，都可能触发系统调用。更可怕的是内存碎片——分配多了，内存池就变成「瑞士奶酪」，到处是洞。

我的做法是：预分配一大块内存，自己管理。

// 简单的内存池实现
class OrderPool {
    static constexpr size_t POOL_SIZE = 1024 * 1024; // 1M个订单
    char buffer[POOL_SIZE * sizeof(Order)];
    std::atomic<size_t> next_free{0};
    
public:
    Order* allocate() {
        size_t idx = next_free.fetch_add(1);
        if (idx >= POOL_SIZE) return nullptr; // 池满了
        return new (buffer + idx * sizeof(Order)) Order();
    }
    
    void deallocate(Order*) {
        // 不真正释放，只是标记可用
        // 实际项目中可以用free list
    }
};

这里用了placement new，直接在预分配内存上构造对象。销毁时也不调用delete，而是把内存归还到空闲链表。

避坑指南：我曾经在内存池里忘了处理对齐问题，结果在ARM架构上直接崩溃。记住：alignas不是摆设，特别是用placement new的时候。

Python呢？Python的内存管理是自动的，但你可以用array模块或者numpy来模拟内存池：

import array

# 用array预分配内存，避免对象开销
prices = array.array('d', [0.0]) * 1000000
volumes = array.array('I', [0]) * 1000000

# 直接操作底层数组，没有Python对象开销
prices[0] = 100.5
volumes[0] = 1000

但说实话，Python的array还是不如C++的原始数组快。每次访问都有类型检查，嗯，这是Python的代价。

避免GC（Python/C++对比）

GC是低延迟系统的头号敌人。你想想看，订单簿正在重建，突然GC线程跑起来，把所有线程都停了——这就是所谓的Stop-The-World。

C++这边，我们根本不用GC。RAII（资源获取即初始化）和智能指针基本能解决大部分问题。但要注意：shared_ptr的引用计数是原子操作，高频场景下也有开销。

// 避免shared_ptr的原子操作开销
// 用unique_ptr或者原始指针+内存池
std::unique_ptr<Order> order = std::make_unique<Order>();
// 或者直接用内存池返回的原始指针
Order* order = pool.allocate();

Python这边就麻烦了。CPython的引用计数是即时的，但循环引用就得靠GC来清理。而且Python的GC是分代回收，触发时会有明显的卡顿。

我曾经踩过的坑：在Python订单簿里用了大量dict来存储订单，结果GC频繁触发，导致交易延迟从微秒级飙升到毫秒级。后来改成__slots__ + list，问题才解决。

Python的优化手段有限，但有几个实用技巧：

禁用GC：在交易时段调用gc.disable()，收盘后再手动清理
避免循环引用：用弱引用weakref打破循环
对象池模式：复用对象，减少创建销毁

import gc

# 交易时段禁用GC
gc.disable()

# 手动管理对象池
class OrderPool:
    def __init__(self, size):
        self.pool = [None] * size
        self.free_indices = list(range(size))
    
    def acquire(self):
        idx = self.free_indices.pop()
        if self.pool[idx] is None:
            self.pool[idx] = Order()
        return self.pool[idx]
    
    def release(self, order):
        # 重置对象状态
        order.reset()
        self.free_indices.append(id(order))

但说实话，Python再怎么优化，在延迟敏感场景下还是不如C++。我个人的建议是：用C++写核心引擎，Python做胶水层。这样既享受了Python的开发效率，又保住了C++的性能。

总结对比

优化方向	C++	Python
紧凑数据结构	结构体对齐、SoA、位域	__slots__、array模块
内存池	placement new、自由链表	对象池模式、numpy数组
避免GC	RAII、智能指针、无GC	gc.disable()、弱引用
性能差距	纳秒级	微秒级（有抖动）

嗯，内存优化这事儿，没有银弹。你得根据业务场景、硬件环境、团队能力来权衡。但有一条铁律：理解你的内存访问模式，然后针对性地优化。

最后说一句：不要过早优化。先用profiler找出热点，再针对性地做内存优化。我见过太多人一上来就搞内存池，结果发现瓶颈在别的地方。

📚 课程目录

内存优化：紧凑数据结构设计、内存池与对象复用、避免GC

紧凑数据结构设计

内存池与对象复用

避免GC（Python/C++对比）

总结对比