while（ture）{
	if(有事件可以处理) {
		处理事件；
	}
}

for ( ;; ) {
        //进入事件处理流程
        ngx_process_events_and_timers(cycle);
		//如果收到退出信号，退出死循环，做些其他处理
		...
		...
    }

    //就是获取一个sleep的定时时间
    //设置了ngx_timer_resolution选项就是定时中断
    if (ngx_timer_resolution) {
        timer = NGX_TIMER_INFINITE;
        flags = 0;
    } else {
        //从红黑树的定时器里面拿最小时间
        timer = ngx_event_find_timer();
        flags = NGX_UPDATE_TIME;
		...
		...
    }
    //解决惊群和负载均衡的accept锁
    if (ngx_use_accept_mutex) {
        if (ngx_accept_disabled > 0) {
            ngx_accept_disabled--;

        } else {
            //尝试着去抢锁，抢到锁之后把监听端口的读事件加入epoll
            if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) {
                return;
            }

            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;
    //处理event事件，这是个封装好的东西，主要调用epoll_wait
    //使用epoll 调用的是ngx_epoll_process_events
    (void) ngx_process_events(cycle, timer, flags);
    //计算epoll等待事件触发过程花费的时间
    delta = ngx_current_msec - delta;
    //先处理accept事件
    ngx_event_process_posted(cycle, &ngx_posted_accept_events);

    if (ngx_accept_mutex_held) {
        //把锁放开
        ngx_shmtx_unlock(&ngx_accept_mutex);
    }

    if (delta) {
        //处理红黑树中的超时事件
        ngx_event_expire_timers();
    }
    //放开锁后再去处理posted队列中的事件
    ngx_event_process_posted(cycle, &ngx_posted_events);

if (ngx_accept_disabled > 0) {
   ngx_accept_disabled--;
   } else {
  ....
  ....
}

rev->ready = 1;
//有post flag就根据这个accept判断加入哪个队列
//读事件有可能是新链接过来的情况
if (flags & NGX_POST_EVENTS) {
// accept是监听状态标志位，只有listening相关的事此标志位才为1
   queue = rev->accept ? &ngx_posted_accept_events : &ngx_posted_events;
   ngx_post_event(rev, queue);
} else {
   //没有post flag就立即调用事件回调函数
   rev->handler(rev);
}
 ....
 ....
//写事件一定是加入posted队列
//有post flag就加入posted队列
if (flags & NGX_POST_EVENTS) {
   ngx_post_event(wev, &ngx_posted_events);
} else {
   //没有就立即执行
   wev->handler(wev);
}

	...
	...
    if (ngx_http_init_phases(cf, cmcf) != NGX_OK) {
        return NGX_CONF_ERROR;
    }
	...
	...
	// 执行每个http模块的postconfiguration函数指针
    // 通常是向phase数组里添加handler
    for (m = 0; cf->cycle->modules[m]; m++) {
        if (cf->cycle->modules[m]->type != NGX_HTTP_MODULE) {
            continue;
        }


        module = cf->cycle->modules[m]->ctx;

        if (module->postconfiguration) {
            if (module->postconfiguration(cf) != NGX_OK) {
                return NGX_CONF_ERROR;
            }
        }
    }
	...
	...
	// 调用ngx_create_listening添加到cycle的监听端口数组，只是添加，没有其他动作
    // 设置有连接发生时的回调函数ngx_http_init_connection
    if (ngx_http_optimize_servers(cf, cmcf, cmcf->ports) != NGX_OK) {
        return NGX_CONF_ERROR;
    }

	 // 处理读事件，读取请求头
    // 设置了读事件的handler，可读时就会调用ngx_http_wait_request_handler
    rev->handler = ngx_http_wait_request_handler;
    // 暂时不处理写事件
    c->write->handler = ngx_http_empty_handler;
一旦该tcp连接上面有数据可读，那么ngx_http_wait_request_handler函数会被被调用，由于此时还处于读client发送过来的信息的阶段不会有写事件可以处理，因此写事件的回调函数是个空函数（直接return）。在ngx_http_wait_request_handler函数中主要就是初始化ngx_http_request_t 数据结构用来储存http请求的一些数据（比如解析出来的header），然后开始解析request line。

 	//创建http_request结构体，放到data中去
    c->data = ngx_http_create_request(c);
    if (c->data == NULL) {
        ngx_http_close_connection(c);
        return;
    }
    //开始解析request_line
    //走到这里数据可能还没有读完，后面的函数会继续读
    rev->handler = ngx_http_process_request_line;
    //解析request_line
    ngx_http_process_request_line(rev);

    enum {
        sw_start = 0,
        sw_method,
        sw_spaces_before_uri,
        sw_schema,
        sw_schema_slash,
        sw_schema_slash_slash,
        sw_host_start,
        sw_host,
        sw_host_end,
        sw_host_ip_literal,
        sw_port,
        sw_host_http_09,
        sw_after_slash_in_uri,
        sw_check_uri,
        sw_check_uri_http_09,
        sw_uri,
        sw_http_09,
        sw_http_H,
        sw_http_HT,
        sw_http_HTT,
        sw_http_HTTP,
        sw_first_major_digit,
        sw_major_digit,
        sw_first_minor_digit,
        sw_minor_digit,
        sw_spaces_after_digit,
        sw_almost_done
    } state;

	c->log->action = "reading client request headers";
    //uri读完了，开始读header
    //设置handler
    rev->handler = ngx_http_process_request_headers;
    ngx_http_process_request_headers(rev);
	return;

		//header全部解析完
        if (rc == NGX_HTTP_PARSE_HEADER_DONE) {


            /* a whole header has been parsed successfully */

            ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                           "http header done");

            r->request_length += r->header_in->pos - r->header_name_start;

            r->http_state = NGX_HTTP_PROCESS_REQUEST_STATE;
            //检查一下有些header是否合法
            rc = ngx_http_process_request_header(r);

            if (rc != NGX_OK) {
                return;
            }
            //开始使用http模块正式处理http请求
            ngx_http_process_request(r);

            return;
        }

    //重新设置读写事件
    //ngx_http_process_request方法负责在接收完HTTP头部后，第一次与各个HTTP模块共同按阶段处理请求
    //如果ngx_http_process_request没能处理完请求，这个请求上的事件再次被触发，那就将由此方法继续处理了。
    c->read->handler = ngx_http_request_handler;
    c->write->handler = ngx_http_request_handler;
	/*
	设置ngx_http_request_t结构体的read_event_handler方法ngx_http_block_reading。当再次有读事件到来时，将会调用ngx_http_block_reading方法
	处理请求。而这里将它设置为ngx_http_block_reading方法，这个方法可认为不做任何事，它的意义在于，目前已经开始处理HTTP请求，除非某个HTTP模块重新
	设置了read_event_handler方法，否则任何读事件都将得不到处理，也可似认为读事件被阻塞了。
	*/
    r->read_event_handler = ngx_http_block_reading;
    //头解析完后开始调用各个http模块的handle
    ngx_http_handler(r);
    //处理子请求
    ngx_http_run_posted_requests(c);

	// 得到core main配置
    cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);
    // 获取引擎里的handler数组
    ph = cmcf->phase_engine.handlers;
    // 从phase_handler的位置开始调用模块处理
    // 外部请求的引擎数组起始序号是0，从头执行引擎数组,即先从Post read开始
    // 内部请求，即子请求.跳过post read，直接从server rewrite开始执行，即查找server
    while (ph[r->phase_handler].checker) {

        // 调用引擎数组里的checker
        rc = ph[r->phase_handler].checker(r, &ph[r->phase_handler]);

        // checker会检查handler的返回值
        // 如果handler返回again/done那么就返回ok
        // 退出引擎数组的处理
        // 由于r->write_event_handler = ngx_http_core_run_phases
        // 当再有写事件时会继续从之前的模块执行
        //
        // 如果checker返回again，那么继续在引擎数组里执行
        // 模块由r->phase_handler指定，可能会有阶段的跳跃
        if (rc == NGX_OK) {
            return;
        }
	}

typedef struct ngx_http_phase_handler_s  ngx_http_phase_handler_t;


typedef ngx_int_t (*ngx_http_phase_handler_pt)(ngx_http_request_t *r,
    ngx_http_phase_handler_t *ph);

struct ngx_http_phase_handler_s {
    //框架实现的checker方法
    ngx_http_phase_handler_pt  checker;
    //http模块实现的handler方法
    ngx_http_handler_pt        handler;
    //下一个阶段序号
    ngx_uint_t                 next;
};

typedef struct {
    // 存储所有handler/checker的数组，里面用next实现阶段的快速跳转
    ngx_http_phase_handler_t  *handlers;

    // server重写的跳转位置
    ngx_uint_t                 server_rewrite_index;

    // location重写的跳转位置
    ngx_uint_t                 location_rewrite_index;
} ngx_http_phase_engine_t;

	//执行当前阶段的handler方法
    rc = ph->handler(r);
    //返回ok执行下一个阶段
    if (rc == NGX_OK) {
        r->phase_handler = ph->next;
        return NGX_AGAIN;
    }
    //执行下一个handler 因为一个阶段可能会有多个handler
    if (rc == NGX_DECLINED) {
        r->phase_handler++;
        return NGX_AGAIN;
    }
    //返回这个直接返回，把控制权交给epoll下次继续执行这个方法
    if (rc == NGX_AGAIN || rc == NGX_DONE) {
        return NGX_OK;
    }


    /* rc == NGX_ERROR || rc == NGX_HTTP_...  */
    //错误之类的错误码结束请求
    ngx_http_finalize_request(r, rc);

    return NGX_OK;

	ngx_int_t  rc;
    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                   "rewrite phase: %ui", r->phase_handler);
    rc = ph->handler(r);

    if (rc == NGX_DECLINED) {
        r->phase_handler++;
        return NGX_AGAIN;
    }
    //不用到下一个handler会再次被调用
    if (rc == NGX_DONE) {
        return NGX_OK;
    }

    /* NGX_OK, NGX_AGAIN, NGX_ERROR, NGX_HTTP_...  */

    ngx_http_finalize_request(r, rc);

    return NGX_OK;

	// 检查请求是否有handler，也就是location里定义了handler
    if (r->content_handler) {
        // 设置写事件为ngx_http_request_empty_handler
        // 即暂时不再进入ngx_http_core_run_phases
        // 这是因为内容产生阶段已经是“最后”一个阶段了，不需要再走其他阶段
        // 之后发送数据时会改为ngx_http_set_write_handler
        // 但我们也可以修改，让写事件触发我们自己的回调
        r->write_event_handler = ngx_http_request_empty_handler;


        // 调用location专用的内容处理handler
        // 返回值传递给ngx_http_finalize_request
        // 相当于处理完后结束请求
        // 这种用法简化了客户代码，相当于模板方法模式
        // rc = handler(r); ngx_http_finalize_request(rc);
        //
        // 结束请求
        // 但如果count>1，则不会真正结束
        // handler可能返回done、again,例如调用read body
        ngx_http_finalize_request(r, r->content_handler(r));

        // 需要在之后的处理函数里继续处理，不能调用write_event_handler
        return NGX_OK;
    }

    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                   "content phase: %ui", r->phase_handler);

    // 没有专门的handler
    // 调用每个模块自己的处理函数
    rc = ph->handler(r);

    if (rc != NGX_DECLINED) {
        ngx_http_finalize_request(r, rc);
        return NGX_OK;
    }

    /* rc == NGX_DECLINED */

    // 模块handler返回decline，表示不处理
    ph++;

    // 这里要检查引擎数组是否结束，最后一个元素是空的
    if (ph->checker) {
        // 继续在本阶段（rewrite）里查找下一个模块
        // 索引加1
        r->phase_handler++;

        // again继续引擎数组的循环
        return NGX_AGAIN;
    }