前面我们介绍了Nginx的多进程模型，多个worker进程间通信 主要是用共享内存来实现的。

今天我们就来学习下Nginx的共享内存。

那么进程该如何创建共享内存呢？

如果按照使用我们的malloc来分配内存的话，只会分配出进程的私有内存，并不能在多个worker进程间共享。Linux为我们封装了POSIX API 如 mmap, munmap。

Nginx已经为我们封装了一套统一的接口来使用共享内存：

文件名:ngx_cycle.h

typedef struct ngx_shm_zone_s  ngx_shm_zone_t;

typedef ngx_int_t (*ngx_shm_zone_init_pt) (ngx_shm_zone_t *zone, void *data);

struct ngx_shm_zone_s {
    void                     *data;  // 
    ngx_shm_t                 shm;   // 共享内存关键结构
    ngx_shm_zone_init_pt      init;  // 初始回调函数
    void                     *tag;   // 标签 一般设置为模块名 类似包名 防止shm.name重复
    void                     *sync;
    ngx_uint_t                noreuse;  /* unsigned  noreuse:1; */
};

文件名:ngx_shmem.h

typedef struct {
    u_char      *addr;  // 分配内存的起始地址
    size_t       size;  // 内存大小
    ngx_str_t    name;  // 共享内存名称
    ngx_log_t   *log;   // 日志
    ngx_uint_t   exists;   /* unsigned  exists:1;  */
} ngx_shm_t;

// 创建共享内存快
ngx_int_t ngx_shm_alloc(ngx_shm_t *shm);
// 释放共享内存快
void ngx_shm_free(ngx_shm_t *shm);

Nginx主要使用了共享内存的模块：

这里主要用到了2种数据结构：

红黑树：比如限速，流控，缓存等。 因为这些场景需要快速增加 删除节点。

单链表：这种场景只需要把信息串起来就可以了。

Nginx为了保证多个worker进程之间同步，防止多个进程同时写共享内存块，从而引入了自旋锁。

如果进程1持有了锁，那么进程2会不停地去访问这把锁。打个比喻的话，就类似一个坑已经被进程1蹲了，那么进程2来了就在门口一直敲门。正是由于这种机制，Nginx要求所有的模块都要快速使用共享内存，即：快速获得锁，快速释放锁。一旦出现有拿着锁 长时间不放的，就会严重降低性能。

我们来一起了解一下Nginx锁的相关数据结构

文件名：ngx_shmtx.h

typedef struct {
    ngx_atomic_t   lock;
} ngx_shmtx_sh_t;


typedef struct {
    ngx_atomic_t  *lock;    // 指向ngx_shmtx_sh_t的lock锁
    ngx_uint_t     spin;    // 自选次数
} ngx_shmtx_t;

// 创建互斥锁
ngx_int_t ngx_shmtx_create(ngx_shmtx_t *mtx, ngx_shmtx_sh_t *addr, u_char *name);
// 销毁互斥锁
void ngx_shmtx_destroy(ngx_shmtx_t *mtx);
// 无阻塞试图获取互斥锁
ngx_uint_t ngx_shmtx_trylock(ngx_shmtx_t *mtx);
// 阻塞方式获取锁
void ngx_shmtx_lock(ngx_shmtx_t *mtx);
// 释放互斥锁
void ngx_shmtx_unlock(ngx_shmtx_t *mtx);

Nginx锁的操作方法：

此外，Nginx还使用了Slab管理共享内存。 下篇继续

#程序员##Nginx#