nginx进程间同步机制-互斥锁

nginx锁的实现方式

nginx的互斥锁有几种实现方式，可基于原子操作/信号量，文件锁。nginx 对上层屏蔽了锁实现

第1种实现， 当不支持原子操作时， 会使用文件锁来实现
ngx_shmtx_t互斥锁， 这时它仅有fd和name成员（实际上还有spin成员，但这时没有任何意义） 。 这两个成员使用14.7节介绍的文件锁来提供阻塞、 非阻塞的互斥锁。
第2种实现， 支持原子操作却又不支持信号量。
第3种实现， 在支持原子操作的同时， 操作系统也支持信号量。

互斥锁的数据结构

nginx由于需要兼容跨平台，封装实现了ngx_shmtx_t

typedef struct{
#if（NGX_HAVE_ATOMIC_OPS）
	//原子变量锁
	ngx_atomic_t*lock；
  #if（NGX_HAVE_POSIX_SEM）
	//semaphore为1时表示获取锁将可能使用到的信号量ngx_uint_t semaphore；
	//sem就是信号量锁
    ngx_atomic_t  *wait;      // 阻塞等待的进程数
    ngx_uint_t     semaphore;
	sem_t sem；
  #endif
#else
	//使用文件锁时fd表示使用的文件句柄
	ngx_fd_t fd；
	//name表示文件名
	u_char*name；
	#endif
	/*自旋次数， 表示在自旋状态下等待其他处理器执行结果中释放锁的时间。 由文件锁实现时， spin没有任何意义*/
	ngx_uint_t spin；
}ngx_shmtx_t；

实现接口

互斥锁的创建

ngx_int_t ngx_shmtx_create（ngx_shmtx_t*mtx,void*addr,u_char*name）
{ 
	mtx-＞lock=addr；//注意， 当spin值为-1时， 表示不能使用信号量， 这时直接返回成功
	if（mtx-＞spin==（ngx_uint_t） -1） {
		return NGX_OK；
	}
	//spin值默认为2048
	mtx-＞spin=2048；
	//同时使用信号量
#if（NGX_HAVE_POSIX_SEM）
	//以多进程使用的方式初始化sem信号量， sem初始值为0
	if（sem_init（＆mtx-＞sem， 1， 0） ==-1） {
		ngx_log_error（NGX_LOG_ALERT,ngx_cycle-＞log,ngx_errno，"sem_init（） failed"） ；
	}
	else
	{
		//在信号量初始化成功后， 设置semaphore标志位为1
		mtx-＞semaphore=1；
	}
#endif
	return NGX_OK；
}

nginx信号量可作为进程间的互斥锁来使用。

int sem_init（sem_t*sem,int pshared,unsigned int value） ；

其中，pshared参数是指定进程间同步和线程间同步的方式。

基于原子操作和信号量的锁的实现：

非阻塞尝试获取锁

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

获取锁

void
ngx_shmtx_lock(ngx_shmtx_t *mtx)
{
    ngx_uint_t         i, n;
    for ( ;; ) {
        // 获取到锁则返回
        if (*mtx->lock == 0 && ngx_atomic_cmp_set(mtx->lock, 0, ngx_pid)) {
            return;
        }
        if (ngx_ncpu > 1) {

            for (n = 1; n < mtx->spin; n <<= 1) {
                //随着长时间没有获得到锁， 将会执行更多次PAUSE才会检查锁
                for (i = 0; i < n; i++) {
                    //对于多处理器系统， 执行ngx_cpu_pause可以降低功耗
                    ngx_cpu_pause();
                }
                // 再次检测获取锁
                if (*mtx->lock == 0 && ngx_atomic_cmp_set(mtx->lock, 0, ngx_pid))
                {
                    return;
                }
            }
        }

#if (NGX_HAVE_POSIX_SEM)

        if (mtx->semaphore) {
            // 阻塞等待的进程+1
            (void) ngx_atomic_fetch_add(mtx->wait, 1);

            if (*mtx->lock == 0 && ngx_atomic_cmp_set(mtx->lock, 0, ngx_pid)) {
                // 获得锁，阻塞等待的进程-1
                (void) ngx_atomic_fetch_add(mtx->wait, -1);
                return;
            }
            //如果信号量值小于等于0等待阻塞，直到等待到信号量，如果出错则退出，否则等待
            while (sem_wait(&mtx->sem) == -1) {
                ngx_err_t  err;
                err = ngx_errno;
                if (err != NGX_EINTR) {
                    break;
                }
            }
            continue;
        }
#endif
        // 使用信号量则不让出当前处理器sem_wait代替了
        ngx_sched_yield();
    }
}

解锁

通过通知waitup，唤醒其他等待加锁的进程。

void ngx_shmtx_unlock(ngx_shmtx_t *mtx)
{
    if (mtx->spin != (ngx_uint_t) -1) {
        ngx_log_debug0(NGX_LOG_DEBUG_CORE, ngx_cycle->log, 0, "shmtx unlock");
    }

    if (ngx_atomic_cmp_set(mtx->lock, ngx_pid, 0)) {
        ngx_shmtx_wakeup(mtx);
    }
}

static void
ngx_shmtx_wakeup(ngx_shmtx_t *mtx)
{
#if (NGX_HAVE_POSIX_SEM)
    ngx_atomic_uint_t  wait;

    if (!mtx->semaphore) {
        return;
    }

    for ( ;; ) {

        wait = *mtx->wait;

        if ((ngx_atomic_int_t) wait <= 0) {
            return;
        }

        if (ngx_atomic_cmp_set(mtx->wait, wait, wait - 1)) {
            break;
        }
    }

    ngx_log_debug1(NGX_LOG_DEBUG_CORE, ngx_cycle->log, 0,
                   "shmtx wake %uA", wait);

    if (sem_post(&mtx->sem) == -1) {
        ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, ngx_errno,
                      "sem_post() failed while wake shmtx");
    }

#endif
}

互斥锁的销毁

void
ngx_shmtx_destroy(ngx_shmtx_t *mtx)
{
#if (NGX_HAVE_POSIX_SEM)

    if (mtx->semaphore) {
        if (sem_destroy(&mtx->sem) == -1) {
            ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, ngx_errno,
                          "sem_destroy() failed");
        }
    }

#endif
}