nginx源码解析（1）

目前阅读nginx源码已经一个多月了，写点东西记录一下，加深下自己的理解，如发现错误，欢迎与我进行沟通讨论。

1 nginx工作模式

nginx默认采用多进程的方式，即一个主进程master进程与多个子进程worker进程，master进程的主要作用是与用户进行交互并管理worker进程，真正的业务处理（如网络事件）是由worker进程来实现的，多个worker进程之间的关系是平等的，他们会通过竞争机制来获取处理客户端的请求。

进程模型图：

（图片来源自网络，侵删）

如图所示，用户通过信号与master进程进行交互，master进程同样通过信号来通知worker进程。nginx在工作时，会先进行各个模块的初始化，创建监听文件描述符，随后根据用户的配置来选择是单进程工作还是多进程工作，若是多进程工作则会根据用户配置fork出多个worker进程（worker进程的选择一般与CPU的个数相同），master进程在创建出worker进程后，会不断的循环来处理用户发送的信号。
worker进程被创建后，每个worker进程中都会继承master进程的事件处理模型（可由用户配置），默认为epoll模型，同时也会继承监听描述符。如果每个worker进程都进行监听，当又accept事件到来时，所有进程都会被唤醒，但最终只有一个进程可以进行处理，浪费了其他CPU的资源，这种现象称为惊群现象。nginx为避免这种现象，引入了进程锁（共享内存中队医便下个进行修改的原子操作），worker进程会竞争锁，竞争到锁的进程，会将listen事件添加到epoll中，当又accept事件到来时，可以进行处理，处理完accept事件后，会释放锁。以便让其他进程获取到锁来处理客户请求。

2 通过源码剖析nginx进程模型

main
{
    
    ngx_cycle_t  * cycle; //cycle 可理解为一个循环，一个nginx对应一个cycle
    ngx_debug_init();
    ngx_pid = ngx_getpid(); //获取进程号
    //一系列初始化，日志，ssl,创建内存池
    ngx_log_init(); 
    ngx_ssl_init();
    ngx_create_pool();
 	//核心，初始化cycle,在该部分中会初始化各个模块，解析配置文件，将对应命令行配置给各个模块
 	//创建监听句柄等等
    cycle = ngx_init_cycle(&init_cycle);
    // 信号处理
    if (ngx_signal) {
        return ngx_signal_process(cycle, ngx_signal);
    }
    //进程选择单进程还是多进程
    if (ngx_process == NGX_PROCESS_SINGLE)
    {
        ngx_single_process_cycle(cycle);
    } else 
    {
    	//在此函数中进行worker进程的创建
        ngx_master_process_cycle(cycle);
    }
    return 0;
}

ngx_master_process_cycle（）
{
	//一系列的信号处理相关

	//创建worker进程
	ngx_start_worker_processes(cycle, ccf->worker_processes, NGX_PROCESS_RESPAWN);
	//创建缓存管理进程
    ngx_start_cache_manager_processes(cycle, 0);
	//创建进程后，master进程会进入死循环，通过信号来管理worker进程
	for(;;)
	{
		//master进程会进入休眠，当收到信号集外的信号会将其唤醒
		sigsuspend(&set);
		if (ngx_terminate){...}   //中止
		if (ngx_quit){...}        //离开
		if (ngx_reconfigure){...} //重新配置
		if (ngx_restart){...}     //重启
		...
	}
}

ngx_start_worker_processes
{
	//创建进程，创建后，会调用回调函数 ngx_worker_process_cycle
	  for (i = 0; i < n; i++)
	  {
        ngx_spawn_process(cycle, ngx_worker_process_cycle,
                          (void *) (intptr_t) i, "worker process", type);

        ch.pid = ngx_processes[ngx_process_slot].pid;
        ch.slot = ngx_process_slot;
        ch.fd = ngx_processes[ngx_process_slot].channel[0];

        ngx_pass_open_channel(cycle, &ch);
    }
}
//该函数会进行worker进程相关的初始化，事件以及定时器相关事件处理
ngx_worker_process_cycle
{
	//初始化cycle结构体
	 ngx_worker_process_init(cycle, worker);
	 //循环进行事件处理，并检查自身状态
	 for ( ;; ) 
	 {
        if (ngx_exiting) {}
        ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "worker cycle");

		//该函数为核心函数，即处理worker进程中的事件与定时器相关
        ngx_process_events_and_timers(cycle);

        if (ngx_terminate) {}
        if (ngx_quit) {}
        if (ngx_reopen) {}
    }

}

//事件以及定时器相关处理
ngx_process_events_and_timers
{
	//判断是否使用进程锁
	 if (ngx_use_accept_mutex) 
	 {
	 	//可将该变量视为控制进程连接，当大于零时不会去争抢锁
        if (ngx_accept_disabled > 0)
        {
            ngx_accept_disabled--;
        } 
        else
        {
        	//尝试获取进程锁
            if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) {
                return;
            }
            //持有锁，将某个标志位设置为NGX_POST_EVENTS
            if (ngx_accept_mutex_held) 
            {
                flags |= NGX_POST_EVENTS;
            } 
            else 
            {
            	//若没有获取到锁，间隔一段事件后会再去争抢锁
                if (timer == NGX_TIMER_INFINITE|| timer > ngx_accept_mutex_delay)
                {
                    timer = ngx_accept_mutex_delay;
                }
            }
        }
    }

	//定时器相关，在后续内容中会着重进行介绍
    delta = ngx_current_msec;
    //开启epoll＿wait事件，该函数对应ngx_epoll_process_events
    (void) ngx_process_events(cycle, timer, flags);
    delta = ngx_current_msec - delta;

    ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                   "timer delta: %M", delta);

	//处理连接事件，nginx处理事件的方式是将待处理事件放在一个队列中，循环处理
	//普通事件队列为ngx_postedt_events，accept事件为ngx_posted_accept_events
	//某个worker进程获取锁后，会先处理accept队列中的事件，处理过后，释放锁，再处理普通的读写事件
    ngx_event_process_posted(cycle, &ngx_posted_accept_events);
	//释放锁，便于其他worker进程争取锁
    if (ngx_accept_mutex_held) {
        ngx_shmtx_unlock(&ngx_accept_mutex);
    }
    //两次定时器事件返回的时间间隔
    if (delta) 
    {
    	//处理超时事件
        ngx_event_expire_timers();
    }
    //处理普通读写事件
    ngx_event_process_posted(cycle, &ngx_posted_events);
}


void ngx_event_process_posted(ngx_cycle_t *cycle, ngx_queue_t *posted)
{
    ngx_queue_t  *q;
    ngx_event_t  *ev;

	//循环处理队列中的事件
    while (!ngx_queue_empty(posted)) 
    {

        q = ngx_queue_head(posted);
        ev = ngx_queue_data(q, ngx_event_t, queue);

        ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                      "posted event %p", ev);

        ngx_delete_posted_event(ev);
		//调用事件的回调函数，来处理事件
		//回调函数是在初始化监听结构体的时候，将处理方法注册上去的
		//以accept事件为例，该回调函数为ngx_event_accept（ngx_event_t *ev）
        ev->handler(ev);
    }
}