【Nginx源码分析】Nginx中的锁与原子操作

阅读量：5826 次

发布时间：2019-06-18

本文共 5228 字，大约阅读时间需要 17 分钟。

李乐

问题引入

多线程或者多进程程序访问同一个变量时，需要加锁才能实现变量的互斥访问，否则结果可能是无法预期的，即存在并发问题。解决并发问题通常有两种方案：

1）加锁：访问变量之前加锁，只有加锁成功才能访问变量，访问变量之后需要释放锁；这种通常称为悲观锁，即认为每次变量访问都会导致并发问题，因此每次访问变量之前都加锁。

2）原子操作：只要访问变量的操作是原子的，就不会导致并发问题。那表达式么i++是不是原子操作呢？

nginx通常会有多个worker处理请求，多个worker之间需要通过抢锁的方式来实现监听事件的互斥处理，由函数ngx_shmtx_trylock实现抢锁逻辑，代码如下：

ngx_uint_t ngx_shmtx_trylock(ngx_shmtx_t *mtx){    return (*mtx->lock == 0 && ngx_atomic_cmp_set(mtx->lock, 0, ngx_pid));}

变量mtx->lock指向的是一块共享内存地址（所有worker都可以访问）；worker进程会尝试设置变量mtx->lock的值为当前进程号，如果设置成功，则说明抢锁成功，否则认为抢锁失败。

注意ngx_atomic_cmp_set设置变量mtx->lock的值为当前进程号并不是无任何条件的，而是只有当变量mtx->lock值为0时才设置，否则不予设置。ngx_atomic_cmp_set是典型的比较-交换操作，且必须加锁或者是原子操作才行，函数实现方式下节分析。

nginx有一些全局统计变量，比如说变量ngx_connection_counter，此类变量由所有worker进程共享，并发执行累加操作，由函数ngx_atomic_fetch_add实现；而该累加操作需要加锁或者时原子操作才行，函数实现方式下节分析。

上面说的mtx->lock和ngx_connection_counter都是共享变量，所有worker进程都可以访问，这些变量在ngx_event_core_module模块的ngx_event_module_init函数创建，且该函数在fork worker进程之前执行。

/* cl should be equal to or greater than cache line size */cl = 128;size = cl            /* ngx_accept_mutex */       + cl          /*ngx_connection_counter */       + cl;         /* ngx_temp_number */           if (ngx_shm_alloc(&shm) != NGX_OK) {     return NGX_ERROR;}shared = shm.addr;if (ngx_shmtx_create(&ngx_accept_mutex, (ngx_shmtx_sh_t *) shared,cycle->lock_file.data)!= NGX_OK)    {        return NGX_ERROR;    }    ngx_connection_counter = (ngx_atomic_t *) (shared + 1 * cl);

这里需要重点思考这么几个问题：

1）cache_line_size是什么？我们都知道CPU与主存之间还存在着高速缓存，高速缓存的访问速率高于主存访问速率，因此主存中部分数据会被缓存在高速缓存中，CPU访问数据时会先从高速缓存中查找，如果没有命中才会访问主从。需要注意的是，主存中的数据并不是一字节一字节加载到高速缓存中的，而是每次加载一个数据块，该数据块的大小就称为cache_line_size，高速缓存中的这块存储空间称为一个缓存行。cache_line_size32字节，64字节不等，通常为64字节。

2）此处cl取值128字节，可是cl为什么一定要大于等于cache_line_size？待下一节分析了原子操作函数实现方式后自然会明白的。

3）函数ngx_shm_alloc是通过系统调用mmap分配的内存空间，首地址为shared；

4）这里创建了三个共享变量ngx_accept_mutex、ngx_connection_counter和ngx_temp_number；函数ngx_shmtx_create使得ngx_accept_mutex->lock变量指向shared；ngx_connection_counter指向shared+128字节位置处，ngx_temp_number指向shared+256字节位置处。

原子操作函数实现方式

据说gcc某版本以后内置了一些原子性操作函数（没有验证），如：

//原子加type __sync_fetch_and_add (type *ptr, type value);//原子减type __sync_fetch_and_sub (type *ptr, type value);//原子比较-交换，返回truebool __sync_bool_compare_and_swap(type* ptr, type oldValue, type newValue, ....);//原子比较交换，返回之前的值type __sync_val_compare_and_swap(type* ptr, type oldValue, type newValue, ....);

通过这些函数很容易解决上面说的多个worker抢锁，统计变量并发累计问题。nginx会检测系统是否支持上述方法，如果不支持会自己实现类似的原子性操作函数。

源码目录下src/os/unix/ngx_gcc_atomic_amd64.h、src/os/unix/ngx_gcc_atomic_x86.h等文件针对不同操作系统实现了若干原子性操作函数。

内联汇编

可通过内联汇编向C代码中嵌入汇编语言。原子操作函数内部都使用到了内联汇编，因此这里需要做简要介绍；

内联汇编格式如下，需要了解以下6个概念：

asm ( 汇编指令: 输出操作数（可选）: 输入操作数（可选）: 寄存器列表（表明哪些寄存器被修改，可选）);

1）寄存器通常有一些简称；

r：表示使用一个通用寄存器，由GCC在%eax/%ax/%al, %ebx/%bx/%bl, %ecx/%cx/%cl, %edx/%dx/%dl中选取一个GCC认为合适的。

a：表示使用%eax / %ax / %al

b：表示使用%ebx / %bx / %bl

c：表示使用%ecx / %cx / %cl

d：表示使用%edx / %dx / %dl

m: 表示内存地址

2）汇编指令；

" popl %0 "" movl %1, %%esi "" movl %2, %%edi "

3）输入操作数，通常格式为——"寄存器简称/内存简称"(值)；这种称为寄存器约束或者内存约束，表明输入或者输出需要借助寄存器或者内存实现。

: "m" (*lock), "a" (old), "r" (set)

4）输出操作数；

//+号表示既是输入参数又是输出参数:"+r" (add)//将寄存器%eax / %ax / %al存储到变量res中:"=a" (res)

5）寄存器列表，如

: "cc", "memory"

cc表示会修改标志寄存器中的条件标志，memory表示会修改内存。

6）占位符与volatile关键字

__asm__ volatile (    "    xaddl  %0, %1;   "    : "+r" (add) : "m" (*value) : "cc", "memory");

volatile表明禁止编译器优化；%0和%1顺序对应后面的输出或输入操作数，如%0对应"+r" (add)，%1对应"m" (*value)。

比较-交换原子实现

现代处理器都提供了比较-交换汇编指令cmpxchgl r, [m]，且是原子操作。其含义如下为，如果eax寄存器的内容与[m]内存地址内容相等，则设置[m]内存地址内容为r寄存器的值。伪代码如下（标志寄存器zf位）：

if (eax == [m]) {    zf = 1;    [m] = r;} else {    zf = 0;    eax = [m];}

因此利用指令cmpxchgl可以很容易实现原子性的比较-交换功能。

但是想想这样有什么问题呢？对于单核CPU来说没任何问题，多核CPU则无法保证。（参考深入理解计算机系统第六章）以Intel Core i7处理器为例，其有四个核，且每个核都有自己的L1和L2高速缓存。

前面提到，主存中部分数据会被缓存在高速缓存中，CPU访问数据时会先从高速缓存中查找；那假如同一块内存地址同时被缓存在核0与核1的L2级高速缓存呢？此时如果核0与核1同时修改该地址内容，则会造成冲突。

目前处理器都提供有lock指令；其可以锁住总线，其他CPU对内存的读写请求都会被阻塞，直到锁释放；不过目前处理器都采用锁缓存替代锁总线（锁总线的开销比较大），即lock指令会锁定一个缓存行。当某个CPU发出lock信号锁定某个缓存行时，其他CPU会使它们的高速缓存该缓存行失效，同时检测是对该缓存行中数据进行了修改，如果是则会写所有已修改的数据；当某个高速缓存行被锁定时，其他CPU都无法读写该缓存行；lock后的写操作会及时会写到内存中。

以文件src/os/unix/ngx_gcc_atomic_x86.h为例。

查看ngx_atomic_cmp_set函数实现如下：

#define NGX_SMP_LOCK  "lock;"static ngx_inline ngx_atomic_uint_tngx_atomic_cmp_set(ngx_atomic_t *lock, ngx_atomic_uint_t old,    ngx_atomic_uint_t set){    u_char  res;    __asm__ volatile (         NGX_SMP_LOCK    "    cmpxchgl  %3, %1;   "    "    sete      %0;       "    : "=a" (res) : "m" (*lock), "a" (old), "r" (set) : "cc", "memory");    return res;}

cmpxchgl即为上面说的原子比较-交换指令；sete取标志寄存器中ZF位的值，并存储在%0对应的操作数。函数最后返回标志寄存器zf位。

累加指令格式为xaddl r [m]，含义如下：

temp = [m];[m] += r;r = temp;

查看ngx_atomic_fetch_add函数实现：

static ngx_inline ngx_atomic_int_tngx_atomic_fetch_add(ngx_atomic_t *value, ngx_atomic_int_t add){    __asm__ volatile (         NGX_SMP_LOCK    "    xaddl  %0, %1;   "    : "+r" (add) : "m" (*value) : "cc", "memory");    return add;}

指令xaddl实现了加法功能，其将%0对应操作数加到%1对应操作数，函数最后返回累加之前的旧值。

这里再回到第一小节，cl取值128字节，且注释表明cl一定要大于等于cache_line_size。cl是什么？三个共享变量之间的偏移量。那假如去掉这个限制，由于每个变量只占8字节，所以三个变量总共占24字节，假设cache_line_size即缓存行大小为64字节，即这三个共享变量可能属于同一个缓存行。

那么当使用lock指令锁定ngx_accept_mutex->lock变量时，会锁定该变量所在的缓存行，从而导致对共享变量ngx_connection_counter和ngx_temp_number同样执行了锁定，此时其他CPU是无法访问这两个共享变量的。因此这里会限制cl大于等于缓存行大小。