ngx accept

尝试获取锁，如果获取了锁，那么还要将当前监听端口全部注册到当前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;

}

/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);

    }

}

巴特西

ngx accept_mutex

尝试获取锁，如果获取了锁，那么还要将当前监听端口全部注册到当前worker进程的epoll当中去获取失败就需要确保此时ls-fd 没有被 epoll 监听

最新文章

热门文章

巴特西

ngx accept_mutex

尝试获取锁，如果获取了锁，那么还要将当前监听端口全部注册到当前worker进程的epoll当中去 获取失败就需要确保此时ls-fd 没有被 epoll 监听

最新文章

热门文章

尝试获取锁，如果获取了锁，那么还要将当前监听端口全部注册到当前worker进程的epoll当中去获取失败就需要确保此时ls-fd 没有被 epoll 监听