[C语言实战]C语言内存管理实战：实现自定义malloc与free（四）

曼岛_2025-05-27 14:53

[C语言实战]C语言内存管理实战：实现自定义malloc与free（四）

摘要：通过实现简化版的内存管理器，深入理解动态内存分配的核心原理。本文包含内存块设计、分配算法、空闲合并策略的完整实现，并附可运行的代码和测试用例。

一、动态内存管理原理剖析

1.1 内存分配的核心需求

  • 动态分配：程序运行时按需请求内存
  • 碎片管理：减少内部碎片（分配过大）和外部碎片（空闲块分散）
  • 效率平衡：时间（搜索速度）与空间（利用率）的权衡

1.2 内存块结构设计

c 复制代码 
typedef struct mem_block {
    size_t size;         // 可用内存大小（不含头部）
    int free;            // 空闲标记（1=空闲，0=占用）
    struct mem_block *next;  // 链表指针
} mem_block;

#define BLOCK_HEADER_SIZE sizeof(mem_block)  // 头部元数据大小

内存布局：

复制代码 
[ Header | Allocated Memory ] -> [ Header | Allocated Memory ] -> ...

1.3 分配策略对比

策略 优点 缺点
首次适应 搜索速度快 容易产生外部碎片
最佳适应 内存利用率高 搜索成本高
最差适应 减少外部碎片 大块请求可能失败

二、自定义malloc/free实现代码（test_alloc.c）

2.1 内存池初始化

c 复制代码 
// 内存块结构体定义（必须在使用前声明）
typedef struct mem_block {
    size_t size;          // 可用内存大小（不含头部）
    int free;             // 空闲标记（1=空闲，0=占用）
    struct mem_block *next; // 链表指针
} mem_block;

#define BLOCK_HEADER_SIZE sizeof(mem_block) // 头部元数据大小
#define HEAP_SIZE (1024*1024)  // 1MB堆空间

static char memory_pool[HEAP_SIZE];
static mem_block *free_list = NULL;

void init_memory_pool() {
    free_list = (mem_block*)memory_pool;
    free_list->size = HEAP_SIZE - BLOCK_HEADER_SIZE;
    free_list->free = 1;
    free_list->next = NULL;
}

2.2 malloc实现（首次适应算法）

c 复制代码 
void* my_malloc(size_t size) {
    if (!free_list) init_memory_pool();  // 首次调用初始化
    
    mem_block *curr = free_list;
    while (curr) {
        if (curr->free && curr->size >= size) {
            // 切割内存块（剩余空间至少能存放头部）
            if (curr->size > size + BLOCK_HEADER_SIZE) {
                mem_block *new_block = (mem_block*)((char*)curr + BLOCK_HEADER_SIZE + size);
                new_block->size = curr->size - size - BLOCK_HEADER_SIZE;
                new_block->free = 1;
                new_block->next = curr->next;
                
                curr->size = size;
                curr->next = new_block;
            }
            curr->free = 0;
            return (void*)((char*)curr + BLOCK_HEADER_SIZE);  // 返回用户空间指针
        }
        curr = curr->next;
    }
    return NULL;  // 内存不足
}

2.3 free实现（相邻块合并）

c 复制代码 
void my_free(void *ptr) {
    if (!ptr) return;
    
    mem_block *block = (mem_block*)((char*)ptr - BLOCK_HEADER_SIZE);
    block->free = 1;
    
    // 前向合并
    mem_block *curr = free_list;
    while (curr) {
        if ((char*)curr + BLOCK_HEADER_SIZE + curr->size == (char*)block) {
            curr->size += BLOCK_HEADER_SIZE + block->size;
            curr->next = block->next;
            block = curr;
        }
        curr = curr->next;
    }
    
    // 后向合并
    if (block->next && block->next->free) {
        block->size += BLOCK_HEADER_SIZE + block->next->size;
        block->next = block->next->next;
    }
}

2.4 test_alloc.c完整代码

c 复制代码 
#include <stddef.h>   // 解决NULL和size_t未定义问题
#include <stdio.h>    // 用于printf调试输出
#include <assert.h>   // 用于断言测试

// 内存块结构体定义（必须在使用前声明）
typedef struct mem_block {
    size_t size;          // 可用内存大小（不含头部）
    int free;             // 空闲标记（1=空闲，0=占用）
    struct mem_block *next; // 链表指针
} mem_block;

#define BLOCK_HEADER_SIZE sizeof(mem_block) // 头部元数据大小
#define HEAP_SIZE (1024*1024)  // 1MB堆空间

static char memory_pool[HEAP_SIZE];
static mem_block *free_list = NULL;

void init_memory_pool() {
    free_list = (mem_block*)memory_pool;
    free_list->size = HEAP_SIZE - BLOCK_HEADER_SIZE;
    free_list->free = 1;
    free_list->next = NULL;
}

void* my_malloc(size_t size) {
    if (!free_list) init_memory_pool();  // 首次调用初始化
    
    mem_block *curr = free_list;
    while (curr) {
        if (curr->free && curr->size >= size) {
            // 切割内存块（剩余空间至少能存放头部）
            if (curr->size > size + BLOCK_HEADER_SIZE) {
                mem_block *new_block = (mem_block*)((char*)curr + BLOCK_HEADER_SIZE + size);
                new_block->size = curr->size - size - BLOCK_HEADER_SIZE;
                new_block->free = 1;
                new_block->next = curr->next;
                
                curr->size = size;
                curr->next = new_block;
            }
            curr->free = 0;
            return (void*)((char*)curr + BLOCK_HEADER_SIZE);  // 返回用户空间指针
        }
        curr = curr->next;
    }
    return NULL;  // 内存不足
}

void my_free(void *ptr) {
    if (!ptr) return;
    
    mem_block *block = (mem_block*)((char*)ptr - BLOCK_HEADER_SIZE);
    block->free = 1;
    
    // 前向合并
    mem_block *curr = free_list;
    while (curr) {
        if ((char*)curr + BLOCK_HEADER_SIZE + curr->size == (char*)block) {
            curr->size += BLOCK_HEADER_SIZE + block->size;
            curr->next = block->next;
            block = curr;
        }
        curr = curr->next;
    }
    
    // 后向合并
    if (block->next && block->next->free) {
        block->size += BLOCK_HEADER_SIZE + block->next->size;
        block->next = block->next->next;
    }
}

// 内存状态打印函数
void print_memory_map() {
    mem_block *curr = free_list;
    printf("Memory Map:\n");
    while (curr) {
        printf("[%s | Size:%6zu] -> ", 
               curr->free ? "FREE " : "USED ", 
               curr->size);
        curr = curr->next;
    }
    printf("NULL\n");
}

/****************** 测试代码 ******************/
int main() {
    // 基础功能测试
    printf("=== 基础分配测试 ===\n");
    int *arr = (int*)my_malloc(10*sizeof(int));
    assert(arr != NULL);
    printf("分配成功，地址：%p\n", arr);
    print_memory_map();

    my_free(arr);
    printf("释放后内存状态：\n");
    print_memory_map();

    return 0;
}

三、验证步骤

3.1 测试环境搭建

bash 复制代码 
# 编译测试程序（保存为 test_alloc.c）
gcc -o test_alloc test_alloc.c -Wall -Wextra
# 运行测试程序
./test_alloc

3.2 预期结果

四、标准库malloc/free实现原理对比

4.1 glibc的ptmalloc核心设计

c 复制代码 
/* glibc的malloc_chunk结构（简化版）*/
struct malloc_chunk {
  size_t      prev_size;  /* 前块大小（当空闲时有效）*/
  size_t      size;       /* 块大小及标志位 */
  struct malloc_chunk* fd; /* 空闲链表的向前指针 */
  struct malloc_chunk* bk; /* 空闲链表的向后指针 */
};
核心机制对比表
特性 自定义实现 glibc ptmalloc
内存来源 静态数组 brk()/mmap()系统调用
分配粒度 按需切割 16字节对齐
空闲管理 单向链表 bins数组（fastbin/smallbin等）
线程安全 无 使用arena锁
大内存处理 不支持 使用mmap独立映射
碎片处理 相邻合并 top chunk回收机制

4.2 标准库内存分配流程

是 否 是 否 malloc调用 请求大小<=128KB? 在arena中查找fastbin/smallbin 使用mmap直接分配 找到合适块? 拆分并返回内存 扩展top chunk 调用brk调整堆顶 创建独立内存映射

五、标准库高级特性实现

5.1 内存对齐分配

c 复制代码 
// glibc的memalign实现原理
void* glibc_memalign(size_t alignment, size_t size) {
    // 1. 分配额外空间用于对齐调整
    void* raw_ptr = malloc(size + alignment - 1);
    
    // 2. 计算对齐地址
    uintptr_t addr = (uintptr_t)raw_ptr;
    uintptr_t aligned_addr = (addr + alignment - 1) & ~(alignment - 1);
    
    // 3. 存储原始指针用于free
    ((void**)aligned_addr)[-1] = raw_ptr;
    
    return (void*)aligned_addr;
}

5.2 内存池优化技术

c 复制代码 
/* glibc的tcache（线程缓存）结构 */
struct tcache_entry {
    struct tcache_entry *next;
};

struct tcache_perthread_struct {
    char counts[TCACHE_MAX_BINS];  // 每个bin的计数
    struct tcache_entry *entries[TCACHE_MAX_BINS];
};
tcache工作流程：
  1. 每个线程维护独立缓存
  2. 小对象优先从tcache分配
  3. 释放时先返回tcache
  4. tcache满时退回全局arena

六、混合使用建议

6.1 何时使用自定义实现

实时系统 已知分配模式 理解原理 需要确定性行为 自定义 内存受限环境 教学/调试

6.2 标准库最佳实践

c 复制代码 
// 示例：使用malloc_trim主动归还内存
#include <malloc.h>

void critical_memory_task() {
    // 执行前清理内存
    malloc_trim(0);
    
    // 执行关键任务
    // ...
    
    // 任务完成后再次清理
    malloc_trim(0);
}

七、扩展实验建议

7.1 Hook标准库函数

c 复制代码 
// 使用dlsym拦截malloc调用
#include <dlfcn.h>

static void* (*real_malloc)(size_t) = NULL;

void* malloc(size_t size) {
    if (!real_malloc) 
        real_malloc = dlsym(RTLD_NEXT, "malloc");
    
    printf("申请 %zu 字节内存\n", size);
    return real_malloc(size);
}

编译命令：gcc -shared -ldl -fPIC -o libmymalloc.so myhook.c

7.2 内存泄漏检测

c 复制代码 
#define _GNU_SOURCE
#include <dlfcn.h>

struct alloc_record {
    void* ptr;
    size_t size;
    const char* file;
    int line;
};

static struct alloc_record allocs[MAX_RECORDS];

void* dbg_malloc(size_t s, const char* file, int line) {
    void *p = malloc(s);
    add_record(p, s, file, line);
    return p;
}

void dbg_free(void *p) {
    remove_record(p);
    free(p);
}

// 使用宏覆盖标准函数
#define malloc(s) dbg_malloc(s, __FILE__, __LINE__)
#define free(p) dbg_free(p)

八、标准库实现演进

8.1 历史版本对比

版本 特性 改进点
glibc 2.3 引入ptmalloc2 多arena支持
glibc 2.10 增加tcache 线程局部缓存提升性能
glibc 2.26 移除malloc hooks 增强安全性
glibc 2.32 新增malloc_info导出XML格式信息 方便内存分析工具集成

8.2 第三方实现对比

c 复制代码 
// jemalloc的分配器注册（示例）
#include <jemalloc/jemalloc.h>

int main() {
    // 显式使用jemalloc
    void *p = je_malloc(1024);
    je_free(p);
}

8.3 主流分配器对比

特性 ptmalloc jemalloc tcmalloc
设计目标 通用型 低碎片 多线程优化
线程缓存 tcache 自动管理 thread cache
大内存处理 mmap extent 中央堆
适用场景 通用服务器 内存敏感型应用 高并发Web服务

希望本教程对您有帮助，请点赞❤️收藏⭐关注支持！欢迎在评论区留言交流技术细节！

相关推荐
m0_736927046 分钟前
使用 Python 将 PowerPoint 转换为 Word 文档
java·开发语言·后端·职场和发展·c#
我叫汪枫6 分钟前
《HTTP 实战：常用调试工具与抓包技巧》
网络·网络协议·http
杜子不疼.15 分钟前
【Rust】路由匹配与参数提取：从 match 语句到 axum 的类型魔法
开发语言·后端·rust
夜晚中的人海34 分钟前
【C++】位运算算法习题
开发语言·c++·算法
googleccsdn36 分钟前
ENSP Pro Lab笔记：配置STP/RSTP/MSTP（4）
网络·笔记·网络协议
裸奔在上海42 分钟前
使用Java做URL短连接还原长链接获取参数
java·开发语言·程序人生·spring
爱吃烤鸡翅的酸菜鱼42 分钟前
如何掌握【Java】 IO/NIO设计模式？工厂/适配器/装饰器/观察者模式全解析
java·开发语言·后端·设计模式·nio
程序员大雄学编程1 小时前
「用Python来学微积分」17. 导数与导函数
开发语言·python·数学·微积分
扶尔魔ocy1 小时前
【QT常用技术讲解】可拖拽文件的Widget--QListWidget
开发语言·qt
枫叶丹41 小时前
【Qt开发】布局管理器（一）-＞ QVBoxLayout垂直布局
开发语言·c++·qt
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03BongoCat - 跨平台键盘猫动画工具04GitLab 零基础入门指南：从安装到项目管理全流程05Linux下V2Ray安装配置指南06NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南07Labelme从安装到标注：零基础完整指南08安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）09在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）10jdk21下载、安装（Windows、Linux、macOS）