nginx进程间的通信

进程间消息传递

共享内存

typedef struct{
	//指向共享内存的其实地址
	u_char* addr;
	//共享内存的长度
	size_t size;
	//这块共享内存的名称
	ngx_str_t name;
	//记录日志的ngx_log_t对象
	ngx_lot_t* log;
	//表示共享内存是否已经分配过的标志位，为1时表示已经存在
	ngx_uint_t exists;
} ngx_shm_t;

Nginx频道

typedef struct{
		//传递的TCP消息中的命令
		ngx_uint_t command;
		//进程ID，一般是发送命令方的进程ID
		ngx_pid_t pid;
		//表示发送命令方在ngx_processes进程数组间的序号
		ngx_int_t slot;
		//通信的套接字句柄
		ngx_fd_t fd;
} ngx_channel_t;

信号

typedef struct{
	//需要处理的信号
	int signo;
	//信号对应的字符串名称
	char* siname;
	//这个信号对应着的Nginx命令
	char* name;
	//收到signo信号后就会回调handler方法
	void (*handler)(int signo);
} ngx_signal_t;

ngx_signal_t signals[] = {
	{	
		ngx_signal_value(NGX_RECOFIGURE_SIGNAL),
		“SIG” ngx_value(NGX_RECONFIGURE_SIGNAL),
		“reload”,
		ngx_signal_handler
},
…
}

ngx_int_t ngx_init_signals(nx_log_t* log)
{
	ngx_signal_t* sig;
	struct signaction sa;
	//遍历signals数组，处理每一个ngx_signal_t类型的结构体
	for(sig = signals; sig->signo != 0; sig++){
		ngx_memzero(&sa, sizeof(struct, sigaction));
		//设置信号的处理方法为handler方法
		sa.sa_handler = sig->handler;
		//将sa中的为全部设置为0
		sigemptyset(&sa.sa_mask);
		//注册信号的回调方法
		if(sigaction(sig->signo, &sa, NULL) == -1){
			ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
“sigaction(%s) failed”, sig->signame);
				return NGX_ERROR;
}
}
	return NGX_OK;
}

进程同步

原子操作

/*
 * Copyright (C) Igor Sysoev
 * Copyright (C) Nginx, Inc.
 */


#include <ngx_config.h>
#include <ngx_core.h>

//函数：基于原子操作的自旋锁方法ngx_spinlock的实现
//参数解释：
//lock：原子变量表达的锁
//value：标志位，锁是否被某一进程占用
//spin：在多处理器系统内，当ngx_spinlock方法没有拿到锁时，当前进程在内核的一次调度中该方法等待其他处理器释放锁的时间
void
ngx_spinlock(ngx_atomic_t *lock, ngx_atomic_int_t value, ngx_uint_t spin)
{

#if (NGX_HAVE_ATOMIC_OPS)//支持原子操作

    ngx_uint_t  i, n;

    //一直处于循环中，直到获取到锁
    for ( ;; ) {

        //lock为0表示没有其他进程持有锁，这时将lock值设置为value参数表示当前进程持有了锁
        if (*lock == 0 && ngx_atomic_cmp_set(lock, 0, value)) {
            return;
        }

        //如果是多处理器系统
        if (ngx_ncpu > 1) {
			/*
在多处理器下，当发现锁被其他进程占用时，当前进程并不是立刻让出正在使用的CPU处理器，而是等待一段时间，看看其他处理器上的进程是否会释放锁，这会减少进程间切换的次数。
*/
            for (n = 1; n < spin; n <<= 1) {
                //随着等待的次数越来越多，实际去检查锁的间隔时间越来越大
                for (i = 0; i < n; i++) {
					/*
ngx_cpu_pause是许多架构体系中专门为了自旋锁而提供的指令，它会告诉CPU现在处于自旋锁等待状态，通常一个CPU会将自己置于节能状态，降低功耗。但是当前进程并没有让出正在使用的处理器。
*/
                    ngx_cpu_pause();//
                }

                /*
检查锁是否被释放了，如果lock值为0且释放了锁后，就把它的值设为value，当前进程持有锁成功并返回
				*/
                if (*lock == 0 && ngx_atomic_cmp_set(lock, 0, value)) {
                    return;
                }
            }
        }

        /*
`		当前进程让出处理器，但仍然处于可执行状态，使得处理器优先调度其他可执行状态的进程，这样，在进程被内核再次调度时，在for循环代码中可以期望其他进程释放锁。
		*/
        ngx_sched_yield();
    }

#else

#if (NGX_THREADS)

#error ngx_spinlock() or ngx_atomic_cmp_set() are not defined !

#endif

#endif

}

信号量

文件锁

Nginx实现的互斥锁

typedef struct{
		#if (	NGX_HAVE_ATOMIC_OPS)
			//原子变量锁
			ngx_atomic_t*	lock;
		#if (NGX_HAVE_POSIX_SEM)
		      //semaphore为1 时表示获取锁将可能使用到的信号量
			ngx_uint_t semaphonre;
			//sem就是信号量锁
			sem_t sem;
		#endif;
		#else
			//使用文件锁时fd表示使用的文件句柄
			ngx_fd_t fd;
			//name表示文件名
			u_char* name;
		#endif
			/*自旋次数，表示在自旋状态下等待其他处理器结果中释放的时间。由文件锁实现，spin没有任何意义*/
			ngx_uint_t spin;
} ngx_shmtx_t;