面试题：C语言内存管理深度优化与服务器高并发场景

高并发 Linux 服务器程序中 C 语言内存管理面临的挑战

线程安全问题
- 多个线程同时访问和修改共享内存区域时，可能导致数据竞争，比如一个线程正在释放一块内存，而另一个线程正在使用它，从而引发未定义行为。
- 对内存分配和释放函数（如 malloc 和 free）的调用不是线程安全的，如果多个线程同时调用，可能会损坏堆数据结构。
内存碎片问题
- 在高并发环境下，频繁的内存分配和释放操作可能导致内存碎片。小的空闲内存块分散在内存中，无法满足较大的内存分配请求，尽管总的空闲内存可能足够。
性能问题
- 传统的内存管理函数（如 malloc 和 free）在高并发场景下可能存在性能瓶颈。锁机制的使用虽然能保证线程安全，但会带来额外的开销，降低并发性能。

设计思路

基于线程本地存储（TLS）：为每个线程分配自己的内存池，减少线程间的竞争。每个线程优先从自己的内存池中分配内存，当本地内存池不足时，再从全局内存池中获取。
对象缓存：对于频繁使用的小对象，创建对象缓存。在对象释放时，不立即归还给内存池，而是放入缓存，下次分配同类对象时优先从缓存中获取。
分层内存管理：将内存管理分为多个层次，如页级管理、块级管理和对象级管理。不同层次负责不同粒度的内存分配和回收，提高管理效率。

关键数据结构

线程本地内存池：

typedef struct ThreadLocalPool {
    char *start;
    char *end;
    char *current;
} ThreadLocalPool;

start 指向内存池的起始地址，end 指向内存池的结束地址，current 用于记录当前可用内存的位置。

全局内存池：

typedef struct GlobalPool {
    char *start;
    char *end;
    struct GlobalPool *next;
} GlobalPool;

start 和 end 分别表示全局内存池块的起始和结束地址，next 用于链接多个全局内存池块。

对象缓存：

typedef struct ObjectCache {
    void *head;
    struct ObjectCache *next;
} ObjectCache;

head 指向缓存对象链表的头节点，next 用于链接多个对象缓存。

函数实现要点

初始化函数
- 初始化线程本地内存池：

void initThreadLocalPool(ThreadLocalPool *pool, size_t size) {
    pool->start = (char *)malloc(size);
    pool->end = pool->start + size;
    pool->current = pool->start;
}

- 初始化全局内存池：

GlobalPool *initGlobalPool(size_t size) {
    GlobalPool *pool = (GlobalPool *)malloc(sizeof(GlobalPool));
    pool->start = (char *)malloc(size);
    pool->end = pool->start + size;
    pool->next = NULL;
    return pool;
}

内存分配函数
- 从线程本地内存池分配内存：

void* allocateFromThreadLocalPool(ThreadLocalPool *pool, size_t size) {
    if (pool->current + size <= pool->end) {
        void *result = pool->current;
        pool->current += size;
        return result;
    }
    return NULL;
}

- 从全局内存池分配内存：

void* allocateFromGlobalPool(GlobalPool **globalPool, size_t size) {
    GlobalPool *current = *globalPool;
    while (current) {
        if (current->start + size <= current->end) {
            void *result = current->start;
            current->start += size;
            return result;
        }
        current = current->next;
    }
    // 如果现有全局内存池不够，分配新的全局内存池块
    GlobalPool *newPool = (GlobalPool *)malloc(sizeof(GlobalPool));
    newPool->start = (char *)malloc(size);
    newPool->end = newPool->start + size;
    newPool->next = *globalPool;
    *globalPool = newPool;
    return newPool->start;
}

内存释放函数
- 将内存释放回线程本地内存池（这里简化处理，实际可能需要更复杂的合并等操作）：

void freeToThreadLocalPool(ThreadLocalPool *pool, void *ptr) {
    // 简单示例，实际可能需要更复杂逻辑确保释放正确
    if (ptr >= pool->start && ptr < pool->end) {
        // 可添加标记等操作，这里省略
    }
}

- 将内存释放回全局内存池：

void freeToGlobalPool(GlobalPool **globalPool, void *ptr) {
    GlobalPool *current = *globalPool;
    while (current) {
        if (ptr >= current->start && ptr < current->end) {
            // 可添加标记等操作，这里省略
            return;
        }
        current = current->next;
    }
}

对象缓存相关函数
- 从对象缓存获取对象：

void* getObjectFromCache(ObjectCache *cache) {
    if (cache->head) {
        void *obj = cache->head;
        cache->head = *((void **)cache->head);
        return obj;
    }
    return NULL;
}

- 将对象放入对象缓存：

void putObjectToCache(ObjectCache *cache, void *obj) {
    *((void **)obj) = cache->head;
    cache->head = obj;
}

星途面试题库

面试题：C语言内存管理深度优化与服务器高并发场景

知识考点

面试题答案

高并发 Linux 服务器程序中 C 语言内存管理面临的挑战

设计思路

关键数据结构

函数实现要点