面试题：C语言自定义内存管理机制实现

Question

假设你需要在一个对内存使用要求极高的嵌入式系统中，设计并实现一个自定义的内存管理机制。该机制需支持固定大小内存块的分配与释放，并且要考虑多线程环境下的并发访问问题。请描述你的设计思路，并给出关键代码片段。

Answer 1

设计思路

1. 内存池结构：
   • 创建一个内存池结构体，用于管理整个内存区域。它包含一个指向内存块数组的指针，以及记录已分配和空闲内存块数量的变量。
   • 每个内存块有一个标志位，用于表示该块是否已被分配。
2. 初始化：
   • 在系统启动时，根据需求初始化内存池，将所有内存块标记为空闲。
3. 分配内存：
   • 遍历内存池，找到第一个空闲的内存块，将其标记为已分配并返回其地址。
   • 如果没有空闲块，则返回错误。
4. 释放内存：
   • 检查要释放的内存块地址是否在内存池范围内，并且已被分配。
   • 如果条件满足，将其标记为空闲。
5. 并发访问：
   • 使用互斥锁（Mutex）来保护对内存池的访问，确保在多线程环境下，同一时间只有一个线程可以操作内存池。

关键代码片段（以C语言为例）

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

// 定义内存块大小
#define BLOCK_SIZE 128
// 定义内存块数量
#define BLOCK_COUNT 100

// 内存块结构体
typedef struct {
    int is_allocated;
    char data[BLOCK_SIZE];
} MemoryBlock;

// 内存池结构体
typedef struct {
    MemoryBlock *blocks[BLOCK_COUNT];
    int free_count;
    pthread_mutex_t mutex;
} MemoryPool;

// 初始化内存池
MemoryPool* init_memory_pool() {
    MemoryPool *pool = (MemoryPool*)malloc(sizeof(MemoryPool));
    if (pool == NULL) {
        return NULL;
    }
    pool->free_count = BLOCK_COUNT;
    for (int i = 0; i < BLOCK_COUNT; i++) {
        pool->blocks[i] = (MemoryBlock*)malloc(sizeof(MemoryBlock));
        if (pool->blocks[i] == NULL) {
            // 释放已分配的内存
            for (int j = 0; j < i; j++) {
                free(pool->blocks[j]);
            }
            free(pool);
            return NULL;
        }
        pool->blocks[i]->is_allocated = 0;
    }
    pthread_mutex_init(&pool->mutex, NULL);
    return pool;
}

// 分配内存
void* allocate_memory(MemoryPool *pool) {
    pthread_mutex_lock(&pool->mutex);
    for (int i = 0; i < BLOCK_COUNT; i++) {
        if (!pool->blocks[i]->is_allocated) {
            pool->blocks[i]->is_allocated = 1;
            pool->free_count--;
            pthread_mutex_unlock(&pool->mutex);
            return pool->blocks[i]->data;
        }
    }
    pthread_mutex_unlock(&pool->mutex);
    return NULL; // 没有空闲内存块
}

// 释放内存
void free_memory(MemoryPool *pool, void *block) {
    pthread_mutex_lock(&pool->mutex);
    for (int i = 0; i < BLOCK_COUNT; i++) {
        if (pool->blocks[i]->data == block && pool->blocks[i]->is_allocated) {
            pool->blocks[i]->is_allocated = 0;
            pool->free_count++;
            break;
        }
    }
    pthread_mutex_unlock(&pool->mutex);
}

// 销毁内存池
void destroy_memory_pool(MemoryPool *pool) {
    pthread_mutex_destroy(&pool->mutex);
    for (int i = 0; i < BLOCK_COUNT; i++) {
        free(pool->blocks[i]);
    }
    free(pool);
}