尝试获取锁，如果获取了锁，那么还要将当前监听端口全部注册到当前worker进程的epoll当中去 获取失败就需要确保此时ls-fd 没有被 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, 0, "accept mutex locked"); //如果本来已经获得锁，则直接返回Ok if (ngx_accept_mutex_held && ngx_accept_events == 0) { 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 = 0; ngx_accept_mutex_held = 1; ////表示当前获取了锁 return NGX_OK; } ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "accept mutex lock failed: %ui", ngx_accept_mutex_held); //这里表示的是以前曾经获取过，但是这次却获取失败了，那么需要将监听端口从当前的worker进程的epoll当中移除，调用的是ngx_disable_accept_events函数 -----当前进程没有获取到锁，证明是由别的进程获取到了。如果ngx_accept_mutex_held的值为1，证明该锁原来是由 //本进程持有，即监听socket原先是加入到了本进程的事件驱动机制当中的。因此这里在进入下一次事件驱动机制(select/ // poll/eploll)之前，我们需要先disable掉 if (ngx_accept_mutex_held) { if (ngx_disable_accept_events(cycle, 0) == NGX_ERROR) { return NGX_ERROR; } ngx_accept_mutex_held = 0; } return NGX_OK; } static ngx_int_t ngx_enable_accept_events(ngx_cycle_t *cycle) { ngx_uint_t i; ngx_listening_t *ls; ngx_connection_t *c; ls = cycle->listening.elts; /*本进程ngx_enable_accept_events把所有listen加入本进程epoll中后，本进程获取到ngx_accept_mutex锁后，在执行accept事件的 过程中如果如果其他进程也开始ngx_trylock_accept_mutex，如果之前已经获取到锁，并把所有的listen添加到了epoll中，这时会因为没法获取到 accept锁，而把之前加入到本进程，但没有accept过的时间全部清除。和ngx_disable_accept_events配合使用 最终只有一个进程能accept到同一个客户端连接 */ for (i = 0; i < cycle->listening.nelts; i++) { c = ls[i].connection; //后面的ngx_add_event->ngx_epoll_add_event中把listening中的c->read->active置1， ngx_epoll_del_event中把listening中置read->active置0 if (c == NULL || c->read->active) { //之前本进程已经添加过，不用再加入epoll事件中，避免重复 continue; } char tmpbuf[256]; snprintf(tmpbuf, sizeof(tmpbuf), "<%25s, %5d> epoll NGX_READ_EVENT(et) read add", NGX_FUNC_LINE); ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, tmpbuf); if (ngx_add_event(c->read, NGX_READ_EVENT, 0) == NGX_ERROR) { //ngx_epoll_add_event return NGX_ERROR; } } return NGX_OK; }
1
/addr为共享内存ngx_shm_alloc开辟的空间中的一个128字节首地址 --cache 长度 ngx_int_t ngx_shmtx_create(ngx_shmtx_t *mtx, ngx_shmtx_sh_t *addr, u_char *name) { mtx->lock = &addr->lock; //直接执行共享内存空间addr中的lock区间中 if (mtx->spin == (ngx_uint_t) -1) { //注意，当spin值为-1时，表示不能使用信号量，这时直接返回成功 return NGX_OK; } mtx->lock 原子操作数，在加锁时，作为判断条件值。 mtx->spin 用于判断mtx->lock的次数，nginx的锁不是盲目的轮询判断或者判断只判断一次，它是选取了一个spin的循环判断次数，超过次数，让出cpu或者等待信号处理。 mtx->spin = 2048; //spin值默认为2048 //同时使用信号量 #if (NGX_HAVE_POSIX_SEM) mtx->wait = &addr->wait; /* int sem init (sem_t sem, int pshared, unsigned int value) , 其中，参数sem即为我们定义的信号量，而参数pshared将指明sem信号量是用于进程间同步还是用于线程间同步，当pshared为0时表示线程间同步， 而pshared为1时表示进程间同步。由于Nginx的每个进程都是单线程的，因此将参数pshared设为1即可。参数value表示信号量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 { mtx->semaphore = 1; //在信号量初始化成功后，设置semaphore标志位为1 } #endif return NGX_OK; }
/* 首先是判断mtx的lock域是否等于0，如果不等于，那么就直接返回false好了，如果等于的话，那么就要调用原子操作ngx_atomic_cmp_set了， 它用于比较mtx的lock域，如果等于零，那么设置为当前进程的进程id号，否则返回false。 */ ngx_uint_t ngx_shmtx_trylock(ngx_shmtx_t *mtx) { return (*mtx->lock == 0 && ngx_atomic_cmp_set(mtx->lock, 0, ngx_pid)); }
使用ngx_pid 对lock赋值，ngx_pid用于区分进程，不可能重复
接下来是一个for循环判断，判断多次无果，才进行下一步休眠操作或等待操作，
接下来是一个选择，在自旋锁直接使用ngx_sched_yield函数，让出cpu，等待下次判断，在共享内存锁多了一个信号量的选择。
等待sem_post唤醒，此时阻塞。
sem_wait和ngx_sched_yield的对比，sem_wait是一个等待通知的机制，sched_yield是一个循环遍历的机制，在自旋锁使用sched_yield是因为自旋时间断，快速循环遍历，在共享内存锁中，可能需要等待时间长，使用sem机制，避免cpu浪费，
void ngx_shmtx_lock(ngx_shmtx_t *mtx) { ngx_uint_t i, n; ngx_log_debug0(NGX_LOG_DEBUG_CORE, ngx_cycle->log, 0, "shmtx lock"); //一个死循环，不断的去看是否获取了锁，直到获取了之后才退出 //所以支持原子变量的 for ( ;; ) { //lock值是当前的锁状态。注意，lock一般是在共享内存中的，它可能会时刻变化，而val是当前进程的栈中变量，下面代码的执行中它可能与lock值不一致 if (*mtx->lock == 0 && ngx_atomic_cmp_set(mtx->lock, 0, ngx_pid)) { return; } //仅在多处理器状态下spin值才有意义，否则PAUSE指令是不会执行的 if (ngx_ncpu > 1) { //循环执行PAUSE，检查锁是否已经释放 for (n = 1; n < mtx->spin; n <<= 1) { //随着长时间没有获得到锁，将会执行更多次PAUSE才会检查锁 for (i = 0; i < n; i++) { ngx_cpu_pause(); } //再次由共享内存中获得lock原子变量的值 if (*mtx->lock == 0// 使用ngx_pid 对lock赋值，ngx_pid用于区分进程，不可能重复，非常巧妙 && ngx_atomic_cmp_set(mtx->lock, 0, ngx_pid)) { return; } } } #if (NGX_HAVE_POSIX_SEM) //支持信号量时才继续执行 if (mtx->semaphore) {//semaphore标志位为1才使用信号量 (void) ngx_atomic_fetch_add(mtx->wait, 1); //重新获取一次可能虚共享内存中的lock原子变量 if (*mtx->lock == 0 && ngx_atomic_cmp_set(mtx->lock, 0, ngx_pid)) { (void) ngx_atomic_fetch_add(mtx->wait, -1); return; } ngx_log_debug1(NGX_LOG_DEBUG_CORE, ngx_cycle->log, 0, "shmtx wait %uA", *mtx->wait); //如果没有拿到锁，这时Nginx进程将会睡眠，直到其他进程释放了锁 /* 检查信号量sem的值，如果sem值为正数，则sem值减1，表示拿到了信号量互斥锁，同时sem wait方法返回o。如果sem值为0或 者负数，则当前进程进入睡眠状态，等待其他进程使用ngx_shmtx_unlock方法释放锁（等待sem信号量变为正数），到时Linux内核 会重新调度当前进程，继续检查sem值是否为正，重复以上流程 */ while (sem_wait(&mtx->sem) == -1) { ngx_err_t err; err = ngx_errno; if (err != NGX_EINTR) {//当EINTR信号出现时，表示sem wait只是被打断，并不是出错 ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, err, "sem_wait() failed while waiting on shmtx"); break; } } ngx_log_debug0(NGX_LOG_DEBUG_CORE, ngx_cycle->log, 0, "shmtx awoke"); continue; //循环检查lock锁的值，注意，当使用信号量后不会调用sched_yield } #endif ngx_sched_yield(); //在不使用信号量时，调用sched_yield将会使当前进程暂时“让出”处理器 } }
//判断锁的lock域与当前进程的进程id是否相等，如果相等的话，那么就将lock设置为0，然后就相当于释放了锁。 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"); } //ngx_atomic_cmp_set 将lock设置0，执行ngx_shmtx_wakeup。如果使用ngx_sched_yield休眠，ngx_shmtx_wakeup函数无意义，ngx_shmtx_wakeup主要唤醒sem。 if (ngx_atomic_cmp_set(mtx->lock, ngx_pid, 0)) { ngx_shmtx_wakeup(mtx); } }