Nginx 源码分析：ngx_array_t

摘要：源文件路径版本主要作用分析是内部使用的数组型数据结构，与语言内置的数组概念上类似，但是有两点主要区别使用内存池来管理内存虽然有预设数组大小的概念，但是在数组元素超出预设值大小时，会在内存池中发生重分配。

版本：1.8.0

srccoreNgx_array.h
srccoreNgx_array.c

ngx_array_t是Nginx内部使用的数组型数据结构，与C语言内置的数组概念上类似，但是有两点主要区别：

1）ngx_array_t使用ngx_pool_t内存池来管理内存；
2）ngx_array_t虽然有预设数组大小的概念，但是在数组元素超出预设值大小时，会在ngx_pool_t内存池中发生重分配。

但是需要指出，虽然ngx_array_t支持超出数组预设值，但是在内存重分配之后并不会重新利用原来的内存，会造成部分内存浪费。

ngx_array_t

typedef struct {
    void        *elts;
    ngx_uint_t   nelts;
    size_t       size;
    ngx_uint_t   nalloc;
    ngx_pool_t  *pool;
} ngx_array_t;

从内存上来看，array是一块连续的内存区域。因此，作为描述数组的结构体需要：

描述起始地址及描述结束地址，此外需要描绘数组元素的大小以便于索引数组的每个元素，以及描述内存区域已使用的大小

这样，ngx_array_t的每个成员变量就很容易理解了：

elts用来描述数组使用的内存块的起始地址；

size用来描述数组元素的大小；

nalloc用来描述内存块最多能容纳的数组元素个数，因此，内存块的结束地址= elts+nalloc*size

nelts用来描述当前内存块已存在的元素个数；

pool表示ngx_array_t使用的内存所在的内存池。

ngx_array_t的使用可以从以下几个方面来分析：

1）ngx_array_t的创建；
2）如何向ngx_array_t添加元素；
3）如何销毁ngx_array_t；

因为ngx_array_t使用elts指针来指向ngx_array_t实际使用的内存块，所以，ngx_array_t的创建分成两部分：

1.ngx_array_t结构体本身的创建；
2.ngx_array_t所管理的内存的创建；

在堆上创建ngx_array_t结构体本身，Nginx提供了函数：

ngx_array_t *ngx_array_create(ngx_pool_t *p, ngx_uint_t n, size_t size);

其定义如下：

ngx_array_t *
ngx_array_create(ngx_pool_t *p, ngx_uint_t n, size_t size)
{
    ngx_array_t *a;

    a = ngx_palloc(p, sizeof(ngx_array_t));
    if (a == NULL) {
        return NULL;
    }

    if (ngx_array_init(a, p, n, size) != NGX_OK) {
        return NULL;
    }

    return a;
}

从源代码可知：在堆上创建ngx_array_t结构体时，同时也创建了其所管理的内存。

两种方式：在堆上创建、在栈上创建

在堆上创建，需要使用ngx_pool_t来管理内存。
= 在栈上创建，直接创建ngx_array_t局部变量即可。

向ngx_pool_t申请。

ngx_array_t所管理内存的创建，Nginx提供了函数：

static ngx_inline ngx_int_t
ngx_array_init(ngx_array_t *array, ngx_pool_t *pool, ngx_uint_t n, size_t size)
{
    /*
     * set "array->nelts" before "array->elts", otherwise MSVC thinks
     * that "array->nelts" may be used without having been initialized
     */

    array->nelts = 0;
    array->size = size;
    array->nalloc = n;
    array->pool = pool;

    array->elts = ngx_palloc(pool, n * size);
    if (array->elts == NULL) {
        return NGX_ERROR;
    }

    return NGX_OK;
}

这个函数很容易看明白。

输入在堆上或栈上创建的ngx_array_t结构体、申请内存使用的ngx_pool_t内存池、申请的数组元素数目、元素的大小。

函数将elts指向申请的内存空间首地址。

向ngx_array_t添加元素就是对内存进行操作。只需要提供elts + nelts * size指针，向其写入size大小的数据即为添加元素。

函数声明：

void *ngx_array_push(ngx_array_t *a);

函数定义：

void *
ngx_array_push(ngx_array_t *a)
{
    void        *elt, *new;
    size_t       size;
    ngx_pool_t  *p;
    // 数组元素超过预设值时发生内存重新分配
    if (a->nelts == a->nalloc) {

        /* the array is full */

        size = a->size * a->nalloc;

        p = a->pool;

        if ((u_char *) a->elts + size == p->d.last
            && p->d.last + a->size <= p->d.end)
        {
            /*
             * the array allocation is the last in the pool
             * and there is space for new allocation
             */

            p->d.last += a->size;
            a->nalloc++;

        } else {
            /* allocate a new array */

            new = ngx_palloc(p, 2 * size);
            if (new == NULL) {
                return NULL;
            }
            // 直接将原来的内容拷贝到新内存块中，原来的内存没有重新利用
            ngx_memcpy(new, a->elts, size);
            a->elts = new;
            a->nalloc *= 2;
        }
    }

    elt = (u_char *) a->elts + a->size * a->nelts;
    a->nelts++;

    return elt;
}

调用ngx_array_push获取分配给插入元素的内存地址。如果元素个数超过预设值，发生重分配内存。原来的内存没有处理，因此会发生浪费。

另外Nginx还提供了ngx_array_push_n这个函数来处理插入n个元素的情况。

可知，ngx_array_push是ngx_array_push_n中n=1是的特殊情况。他们的代码也基本相同。C语言不支持默认值参数，否则，这两个函数可以合成一个。

根据ngx_array_t创建的分析，可知，ngx_array_t的销毁其实就是不去使用ngx_array_t。

因为，如果在堆上创建ngx_array_t，那么有ngx_pool_t负责管理内存，如果在栈上创建ngx_array_t则变量自动销毁。

而ngx_array_t所管理的内存有ngx_pool_t来负责管理。所以，只要不再使用ngx_array_t或者将ngx_array_t指针置空，则ngx_array_t销毁。

但是Nginx提供了一个用来destory的函数，我们来看看它做了些什么。

void
ngx_array_destroy(ngx_array_t *a)
{
    ngx_pool_t  *p;

    p = a->pool;
    // 释放ngx_array_t所管理的内存
    if ((u_char *) a->elts + a->size * a->nalloc == p->d.last) {
        p->d.last -= a->size * a->nalloc;
    }
    // 释放在堆中的ngx_array_t结构体本身
    if ((u_char *) a + sizeof(ngx_array_t) == p->d.last) {
        p->d.last = (u_char *) a;
    }
}

这个函数可能会发生两种重新回收利用内存的情况：

当ngx_array_t所管理的内存正好是ngx_pool_t最近一次分配的内存。

当堆中的ngx_array_t结构体变量本身正好是ngx_pool_t最近一次分配的内存。

所以，在使用完ngx_array_t之后，最好调用该函数，虽然它可能什么都会做，但是也可能进行内存池内存的重新利用，减少内存浪费。