一、原理
nginx的锁是基于共享内存实现的，这点跟redis中利用一个存储（也就是一个键值对）来实现锁的原理是一致的，每一项操作通过检查锁对象的lock域是否为0，来判断能否获取锁并尝试获取锁。
二、锁的类定义
1. 类定义
//锁的定义
typedef struct {
#if (NGX_HAVE_ATOMIC_OPS)
ngx_atomic_t *lock; //如果支持原子锁的话，那么使用它
#if (NGX_HAVE_POSIX_SEM)
ngx_atomic_t *wait;
ngx_uint_t semaphore;
sem_t sem;
#endif
#else
ngx_fd_t fd; //不支持原子操作的话就使用文件锁来实现
u_char *name;
#endif
ngx_uint_t spin; //这是自旋锁么?
} ngx_shmtx_t;
ngx_shmtx_t
2. 框架初始化时机
ngx_event_core_module中调用init函数来初始化这段锁的共享内存
/*后面将会创建size大小的共享内存，这块共享内存将被均分成三段，
分别供ngx_accept_mutex、ngx_connection_counter、
ngx_temp_number 使用。*/
/* cl should be equal to or greater than cache line size */
cl = ;
size = cl /* ngx_accept_mutex */
+ cl /* ngx_connection_counter */
+ cl; /* ngx_temp_number */ //共享内存的初始化
shm.size = size;
shm.name.len = sizeof("nginx_shared_zone");
shm.name.data = (u_char *) "nginx_shared_zone";
shm.log = cycle->log; if (ngx_shm_alloc(&shm) != NGX_OK) { //为共享内存分配内存空间
return NGX_ERROR;
} shared = shm.addr; //获取共享内存的地址 ngx_accept_mutex_ptr = (ngx_atomic_t *) shared; //存放互斥量内存地址的指针
ngx_accept_mutex.spin = (ngx_uint_t) -; //初始化自旋锁的初值为-1 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 + * cl); //ngx_connection_counter为其分配共享内存的内存空间 (void) ngx_atomic_cmp_set(ngx_connection_counter, , ); ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, ,
"counter: %p, %d",
ngx_connection_counter, *ngx_connection_counter); ngx_temp_number = (ngx_atomic_t *) (shared + * cl); //ngx_temp_number的内存空间
init
三、基本操作
1. try_lock
lock域是否为0 -> 尝试获取锁 （获取锁的表现就是在lock存入了该进程的pid）-> 返回结果
//尝试获取锁，原子的方式
ngx_uint_t
ngx_shmtx_trylock(ngx_shmtx_t *mtx)
{
return (*mtx->lock == && ngx_atomic_cmp_set(mtx->lock, , ngx_pid));
}
try_lock
2. lock
循环获取锁
//阻塞的方式获取锁
void
ngx_shmtx_lock(ngx_shmtx_t *mtx)
{
ngx_uint_t i, n; ngx_log_debug0(NGX_LOG_DEBUG_CORE, ngx_cycle->log, , "shmtx lock");
//一个死循环，不断的去看是否获取了锁，直到获取了之后才退出
for ( ;; ) {
//如果获取了锁，那么就可以直接返回了
if (*mtx->lock == && ngx_atomic_cmp_set(mtx->lock, , ngx_pid)) {
return;
}
//如果cpu的数量大于一
if (ngx_ncpu > ) {
for (n = ; n < mtx->spin; n <<= ) {
for (i = ; i < n; i++) {
ngx_cpu_pause();
} if (*mtx->lock ==
&& ngx_atomic_cmp_set(mtx->lock, , ngx_pid))
{
return;
}
}
} ngx_sched_yield();
}
}
lock
3.unlock
是否拥有锁 -> 释放锁
//释放锁
void
ngx_shmtx_unlock(ngx_shmtx_t *mtx)
{
if (mtx->spin != (ngx_uint_t) -) {
ngx_log_debug0(NGX_LOG_DEBUG_CORE, ngx_cycle->log, , "shmtx unlock");
} if (ngx_atomic_cmp_set(mtx->lock, ngx_pid, )) {
ngx_shmtx_wakeup(mtx);
}
}
unlock
四、用锁解决子进程的惊群现象
尝试获取锁 -> 成功 -> 已持有已把监听端口添加到epoll，返回NGX_OK，未添加则添加到epoll中并设置为持有
尝试获取锁 -> 失败 -> 若以前获取过，需要取消监听
//尝试获取锁，如果获取了锁，那么还要将当前监听端口全部注册到当前worker进程的epoll当中去
ngx_int_t
ngx_trylock_accept_mutex(ngx_cycle_t *cycle)
{
if (ngx_shmtx_trylock(&ngx_accept_mutex)) { //尝试获取互斥锁 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, ,
"accept mutex locked");
//如果本来已经获得锁，则直接返回Ok
if (ngx_accept_mutex_held
&& ngx_accept_events ==
&& !(ngx_event_flags & NGX_USE_RTSIG_EVENT))
{
return NGX_OK;
}
//到达这里，说明重新获得锁成功，因此需要打开被关闭的listening句柄，调用ngx_enable_accept_events函数，将监听端口注册到当前worker进程的epoll当中去
if (ngx_enable_accept_events(cycle) == NGX_ERROR) {
ngx_shmtx_unlock(&ngx_accept_mutex);
return NGX_ERROR;
} ngx_accept_events = ;
ngx_accept_mutex_held = ; //表示当前获取了锁 return NGX_OK;
} ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, ,
"accept mutex lock failed: %ui", ngx_accept_mutex_held);
//这里表示的是以前曾经获取过，但是这次却获取失败了，那么需要将监听端口从当前的worker进程的epoll当中移除，调用的是ngx_disable_accept_events函数
if (ngx_accept_mutex_held) {
if (ngx_disable_accept_events(cycle) == NGX_ERROR) {
return NGX_ERROR;
} ngx_accept_mutex_held = ; //表示当前并没有获取锁
} return NGX_OK;
}
ngx_trylock_accept_mutex
参考文献：
https://www.cnblogs.com/549294286/p/6058811.html