[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服务

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

相关推荐
数据与人工智能律师4 分钟前
加密货币投资亏损后，能否以“欺诈”或“不当销售”索赔？
大数据·网络·算法·云计算·区块链
不二狗30 分钟前
每日算法 -【Swift 算法】实现回文数判断！
开发语言·算法·swift
csdn_aspnet2 小时前
Java 程序求圆弧段的面积(Program to find area of a Circular Segment)
java·开发语言
小阳睡不醒3 小时前
计算机网络练习题
网络·计算机网络
进击的_鹏3 小时前
【C++】红黑树的实现
开发语言·c++
且撷相思红豆枝3 小时前
一种比较精简的协议
c语言·网络·嵌入式硬件·esp32
无心水3 小时前
【后端高阶面经：MongoDB篇】41、MongoDB 是怎么做到高可用的？
java·开发语言·mongodb·java面试·高可用·后端高阶面经·后端工程师的高阶面经
无心水3 小时前
【后端高阶面经：MongoDB篇】40、怎么优化MongoDB的查询性能？
java·开发语言·mongodb·java面试·后端高阶面经·后端工程师的高阶面经·java高阶面经
信息化未来3 小时前
pyｔｈｏｎ 生成复杂表格，自动分页等功能
开发语言·数据结构·python
程序猿阿伟3 小时前
《深入Python：新手易踩的语法雷区与进阶启示》
开发语言·python
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】03从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑04【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！05VMware虚拟机安装Win7专业版保姆级教程（附镜像包）06DeepSeek各版本说明与优缺点分析07头歌的数据库的第二次作业的答案08组基轨迹建模 GBTM的介绍与实现（Stata 或 R）09Coze扣子平台完整体验和实践（附国内和国际版对比）10【操作系统】Linux之网络编程(UDP)（头歌作业）