nginx源码分析1———进程间的通信机制一（信号量）

相关介绍

nginx采用信号量辅助原子变量实现互斥锁，本章我们将讨论原子变量在nginx源码里面的应用。
信号量（semaphore）是一种用于提供不同进程间或者一个给定的进程的不同线程间同步手段的原语。nginx采用的信号量是Posix的基于内存的信号量。

相关系统调用

#include<semaphore.h>
int sem_init(sem_t *sem, int shared, unsigned int value);
int sem_destroy(sem_t *sem);
int sem_wait(sem_t *sem);
int sem_post(sem_t *sem);

sem_init用于初始化，sem参数指向应用程序分配的sem_t变量，shared如果为0那么初始化的信号量是在同一个进程的各个线程间共享的，否则是在进程共享的，value是分配给信号量的初始值。
sem_destroy则用于销毁信号量。
sem_wait用于给信号量减1操作，当信号量小于等于0的时候阻塞，直到信号量大于0。
sem_post则是用于给信号量做加1操作。

相关结构

ngx_shmtx.h

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_HAVE_POSIX_SEM，我们这里假定这个宏是开启的，ngx_shmtx_t预处理命令后的结构包含信号量相关变量sem_t类型的sem，其中ngx_atomic_t为原子变量，在宏定义中用volatile修饰，而且还是uint64_t类型的。

初始化

信号量在ngx_shmtx_create中进行初始化

ngx_int_t
ngx_shmtx_create(ngx_shmtx_t *mtx, ngx_shmtx_sh_t *addr, u_char *name)
{
    mtx->lock = &addr->lock;

    if (mtx->spin == (ngx_uint_t) -1) {
        return NGX_OK;
    }

    mtx->spin = 2048;

#if (NGX_HAVE_POSIX_SEM)

    mtx->wait = &addr->wait;
//对信号量进行初始化,初始值为0，而不是1。shared为1，表示进程共享
    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，表示已经成功初始化信号量了
        mtx->semaphore = 1;
    }

#endif

    return NGX_OK;

加锁

信号量的sem_wait操作，在有信号量支持的时候，nginx互斥量加锁操作会采用信号量进行辅助。

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是否为0，如果是0，可能会和其他进程竞争，所以再进行一个原子的比较设置(CAS)
        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) {
                for (i = 0; i < n; i++) {
                    ngx_cpu_pause();
                }
                if (*mtx->lock == 0 && ngx_atomic_cmp_set(mtx->lock, 0, ngx_pid))
                {
                    return;
                }
            }
        }
#if (NGX_HAVE_POSIX_SEM)
        //可以使用信号量且信号量为，已将初始化成功，初始化不成功将走不进这个if
        if (mtx->semaphore) {
        //wait原子加1，这里是表示将有几个进程在此sem_t上面sem_wait，这个要和后面的wakeup函数联系起来理解。
            (void) ngx_atomic_fetch_add(mtx->wait, 1);
            //尝试去获取一次锁，如果成功就wait原子减1，因为程序return掉了，并没有在sem_wait上wait，上一句的原子加1就回滚。
            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);
            //sem_wait减1，如果小于1就阻塞，等待其他进程去wake up
            while (sem_wait(&mtx->sem) == -1) {
                ngx_err_t  err;
                err = ngx_errno;
                //err==EINTR表示中断，不是错误，可以继续sem_wait等待。
                if (err != NGX_EINTR) {
                    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;
        }
#endif
        //yield的实现其实就是usleep(1)
        ngx_sched_yield();
    }
}

解锁

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");
    }
    //解锁，将lock置为0
    if (ngx_atomic_cmp_set(mtx->lock, ngx_pid, 0)) {
        //如果成功将wakeup其他的进程
        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;
        //如果没有进程在信号量上面wait，将直接return。结合上面lock
        if ((ngx_atomic_int_t) wait <= 0) {
            return;
        }
        //如果有程序在上面wait，就减去一个。
        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);
    //接着去sem_post去通知在sem_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
}

销毁

销毁就自然很easy了，在destroy销毁创建的信号量即可

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
}

从本章可以不难看出，信号量在nginx中主要作为互斥量的辅助实现，最重要的也是唯一的区别就是互斥锁在lock的部分，当不使用信号量，也就是关掉这个宏的时候，将采用自旋锁，如果没有关掉，在lock的时候，将在sem_wait上面休眠，并替代usleep让出处理器的部分。