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
}