高并发服务器-内存池技术（基于nginx）

为什么我们需要内存池，他会在什么场景上用呢？

首先内存池主要解决两种问题：

1、频繁的内存分配导致系统线程或进程间竞争，导致分配效率不高

2、频繁的内存分配，很容易导致系统内存碎片，影响系统性能

使用场景：

频繁使用小块内存的场景，比如像http短连接。

nginx内存池实现：

首先，我们来看看nginx内存池是怎么实现的。毕竟，这么优秀的开源软件，还是有很多值得学习的地方。nginx/src/core/ngx_palloc.h ngx_palloc.c 利用C语言接口实现的内存的

首先，数据结构

有两个比较重要的结构:

// 结构被我精简了，利于理解内存池实现
// 大块数据结构，只是一个块的链表
struct ngx_pool_large_t {
    ngx_pool_large_t     *next;
    void                 *alloc;
};

// 小块数据结构
typedef struct {
    u_char               *last;    // 内存数据块已经分配的位置
    u_char               *end;     // 内存数据块的最后位置
    ngx_pool_t           *next;    // 下一个池结构
    ngx_uint_t            failed;  // 尝试分配失败的次数 
} ngx_pool_data_t;

// 内存池结构
struct ngx_pool_t {
    ngx_pool_data_t       d;           // 内存数据块
    size_t                max;         // 每个内存块最大大小
    ngx_pool_t           *current;     // 当前池
    ngx_pool_large_t     *large;       // 大块内存块的指针
};

由这几个结构，就能简单的把内存池一块块的连起来。

首先说一下内存对齐的概念，如果实现内存池，那内存池的数据结构，都应该存放在数据块中，这样才能避免出现内存碎片，内存块的申请也要最好是2的整数倍对齐，根据实际的系统总线位数32 或者64 进行对齐比较合适。一块块的4k的对齐内存块用链表串起来，最后形成了内存池。

为了提高CPU从内存加载数据的速度，对齐的内存地址，每次cpu取数据，如果低于64字节，就能一次加载，而不需要多次加载，提高了cpu访问内存的效率。

为了内存块对齐，会用到posix_memalign函数，能够在分配内存时返回对齐的内存块。

接口和算法实现：

内存池需要实现的接口：创建/销毁池，内存分配，内存释放。

创建内存池：

/*
 * NGX_MAX_ALLOC_FROM_POOL should be (ngx_pagesize - 1), i.e. 4095 on x86.
 * On Windows NT it decreases a number of locked pages in a kernel.
 */
// 这段我没有明白为啥要-1，我觉得不是应该4096也可以吗？这里知道的小伙伴，给个提醒，不胜感激
#define NGX_MAX_ALLOC_FROM_POOL  (ngx_pagesize - 1)


ngx_pool_t *ngx_create_pool(size_t size)
{
    ngx_pool_t  *p;

    // 内存对齐并分配NGX_POOL_ALIGNMENT = 16 
    p = ngx_memalign(NGX_POOL_ALIGNMENT, size); 
    if (p == NULL) {
        return NULL;
    }

    p->d.last = (u_char *) p + sizeof(ngx_pool_t); 
    p->d.end = (u_char *) p + size;
    p->d.next = NULL;
    p->d.failed = 0;

    size = size - sizeof(ngx_pool_t);
    p->max = (size < NGX_MAX_ALLOC_FROM_POOL) ? size : NGX_MAX_ALLOC_FROM_POOL;

    p->current = p;
    p->chain = NULL;
    p->large = NULL;

    return p;
}

分配小内存：

static ngx_inline void *
ngx_palloc_small(ngx_pool_t *pool, size_t size, ngx_uint_t align)
{
    u_char      *m;
    ngx_pool_t  *p;
    p = pool->current;
    do {
        m = p->d.last;
        // 如果需要对齐，则取对齐的后的可分配的下标。
        if (align) {
            m = ngx_align_ptr(m, NGX_ALIGNMENT);
        }

        // 这时候要判断可分配的下标到end结束是否足够分配，不足够则要分配新的块
        if ((size_t) (p->d.end - m) >= size) {
            p->d.last = m + size;
            return m;
        }
        
        // 遍历池中的块，如果又可分配的则分配返回，都没有，则需要分配新的块。
        p = p->d.next;
    } while (p);

    return ngx_palloc_block(pool, size);
}

static void *
ngx_palloc_block(ngx_pool_t *pool, size_t size)
{
    u_char      *m;
    size_t       psize;
    ngx_pool_t  *p, *new;

    psize = (size_t) (pool->d.end - (u_char *) pool);

    m = ngx_memalign(NGX_POOL_ALIGNMENT, psize, pool->log);
    if (m == NULL) {
        return NULL;
    }

    new = (ngx_pool_t *) m;

    new->d.end = m + psize;
    new->d.next = NULL;
    new->d.failed = 0;

    m += sizeof(ngx_pool_data_t);
    m = ngx_align_ptr(m, NGX_ALIGNMENT);
    new->d.last = m + size;

    // 这里如果遍历对池中剩下的最后一点不足分配的失败次数累计，如果超出4次不能分配成功，
    // 则将对应的当前的可使用的块切换到下一块。
    for (p = pool->current; p->d.next; p = p->d.next) {
        if (p->d.failed++ > 4) {
            pool->current = p->d.next;
        }
    }
    // 把新块加到最后的块上
    p->d.next = new;

    return m;
}

分配超过4k的大块

比较简单，直接创建并加入到链表中

static void *
ngx_palloc_large(ngx_pool_t *pool, size_t size)
{
    void              *p;
    ngx_uint_t         n;
    ngx_pool_large_t  *large;

    p = ngx_alloc(size, pool->log);
    if (p == NULL) {
        return NULL;
    }

    n = 0;
    // 如果大块链表有释放的空闲节点，则取出来用
    for (large = pool->large; large; large = large->next) {
        if (large->alloc == NULL) {
            large->alloc = p;
            return p;
        }

        if (n++ > 3) {
            break;
        }
    }
    // 大块的数据结构部分，需要通过分配小块的内存来获得
    large = ngx_palloc_small(pool, sizeof(ngx_pool_large_t), 1);
    if (large == NULL) {
        ngx_free(p);
        return NULL;
    }

    large->alloc = p;
    large->next = pool->large;
    pool->large = large;

    return p;
}

释放

最后是释放只需要释放大块，小块的在线程池退出时释放

ngx_int_t
ngx_pfree(ngx_pool_t *pool, void *p)
{
    ngx_pool_large_t  *l;

    // 只置空，不删除链表，后续可能新增大块会用到。
    for (l = pool->large; l; l = l->next) {
        if (p == l->alloc) {
            ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
                           "free: %p", l->alloc);
            ngx_free(l->alloc);
            l->alloc = NULL;

            return NGX_OK;
        }
    }

    return NGX_DECLINED;
}

这就是一个内存池的实现，代码简洁。

若时多线程要使用内存池，个人建议每个线程维护自己的线程池，不要多线程共享内存池。