内存管理优化：动态分配策略、内存池与碎片防治

说到C语言的内存管理，我做了十几年嵌入式开发，踩过的坑真不少。动态内存分配看似简单，但用不好就是灾难。今天咱们聊聊怎么把这块做好。

一、动态内存分配的核心问题

先说说malloc/free。这俩函数用起来方便，但问题也明显。我在项目中遇到过几次内存泄漏，查起来真是头疼。说白了，动态内存分配有三大痛点：

• 分配开销大：每次malloc都要走系统调用，频繁分配性能堪忧
• 内存碎片：频繁分配释放，堆内存变得支离破碎
• 泄漏风险：忘记free，内存就悄悄溜走了

二、动态内存分配策略

我一般把分配策略分成三种场景：

场景	推荐策略	说明
大小固定、频繁使用	内存池	预分配，按块管理
大小变化、低频使用	直接malloc	注意配对free
大小变化、高频使用	slab分配器	类似Linux内核的做法

举个例子。我做过一个网络协议栈，数据包频繁创建销毁。一开始用malloc/free，性能惨不忍睹。后来改成内存池，吞吐量提升了3倍。

// 不好的做法：频繁分配释放
for (int i = 0; i < 10000; i++) {
    char *buf = (char*)malloc(1024);
    // 使用buf
    free(buf);
}

// 好的做法：复用内存
char *buf = (char*)malloc(1024);
for (int i = 0; i < 10000; i++) {
    // 重置buf内容，继续使用
    memset(buf, 0, 1024);
    // 使用buf
}
free(buf);

三、内存池设计实战

内存池说白了就是提前申请一大块内存，然后自己管理。我习惯这样设计：

typedef struct mem_pool {
    void *pool_start;      // 池起始地址
    size_t block_size;     // 每个块大小
    int total_blocks;      // 总块数
    int free_blocks;       // 空闲块数
    int *free_list;        // 空闲块索引链表
} mem_pool_t;

// 初始化内存池
mem_pool_t* pool_create(size_t block_size, int count) {
    mem_pool_t *pool = malloc(sizeof(mem_pool_t));
    pool->pool_start = malloc(block_size * count);
    pool->block_size = block_size;
    pool->total_blocks = count;
    pool->free_blocks = count;
    
    // 初始化空闲链表
    pool->free_list = malloc(sizeof(int) * count);
    for (int i = 0; i < count; i++) {
        pool->free_list[i] = i;
    }
    return pool;
}

// 从池中分配
void* pool_alloc(mem_pool_t *pool) {
    if (pool->free_blocks == 0) return NULL;
    
    int index = pool->free_list[--pool->free_blocks];
    return (char*)pool->pool_start + index * pool->block_size;
}

// 释放回池中
void pool_free(mem_pool_t *pool, void *ptr) {
    int index = ((char*)ptr - (char*)pool->pool_start) / pool->block_size;
    pool->free_list[pool->free_blocks++] = index;
}

四、减少内存碎片的技巧

内存碎片分两种：外部碎片和内部碎片。外部碎片是空闲内存不连续，内部碎片是分配的内存用不完。

我曾经在一个长期运行的服务器程序里，发现运行一周后内存占用翻倍。查了半天，就是碎片问题。后来用了这几个方法：

1. 固定大小分配：把不同大小的请求归类，用不同内存池处理
2. 伙伴系统：按2的幂次分配，合并时方便
3. 延迟释放：不立即free，而是缓存起来复用

// 伙伴系统简化示例
#define MIN_BLOCK 32
#define MAX_ORDER 10

typedef struct buddy_system {
    void *memory;
    int order;  // 最大阶数
    struct list_head free_list[MAX_ORDER + 1];
} buddy_system_t;

// 分配2^order大小的块
void* buddy_alloc(buddy_system_t *sys, int order) {
    // 查找可用块
    for (int i = order; i <= sys->order; i++) {
        if (!list_empty(&sys->free_list[i])) {
            // 如果找到的块比需要的大，就分裂
            while (i > order) {
                // 分裂逻辑
                i--;
            }
            return allocated_block;
        }
    }
    return NULL;
}

五、知识体系总览

下面这张图是我整理的内存管理优化核心逻辑，你看完应该能有个整体把握：

六、避坑指南

最后说说我踩过的坑，希望能帮你少走弯路：

• 别在中断里malloc：中断上下文不能睡眠，malloc可能触发缺页中断
• 注意内存对齐：有些硬件要求数据按4字节或8字节对齐
• 定期检查泄漏：用valgrind或自己写钩子函数监控
• 别过度优化：先分析热点，再决定要不要上内存池

嗯，内存管理这块就聊这么多。记住一个原则：能不动态分配就别动态分配，能复用就别重新申请。这样你的程序会更稳定，性能也更好。