为什么我们需要内存池,他会在什么场景上用呢?
首先内存池主要解决两种问题:
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;
}
这就是一个内存池的实现,代码简洁。
若时多线程要使用内存池,个人建议每个线程维护自己的线程池,不要多线程共享内存池。