Nginx event核心模块之process部分详解（四）
Nginx event核心模块之process（四）
这个是event模块核心运行部分，主要函数涉及event_process_init和event_process_and_timer两个部分。其中event_init部分主要包括一下部分内容：
1) 初始化cycle_connections信息
2) 初始化cycle_read_events以及cycle_write_events信息，这两个部分主要初始化关于cycle的信息。
3) 获取listening信息
4) 初始化connection info
5) 设置rev处理函数为event_accept，这三个部分主要初始化从listen数据信息中关于bind socket的信息，并初始化处理函数。
6) 把rev事件添加到epoll侦听队列中
其中event_process_and_timer函数，是在worker进程中的循环的主体部分，里面具有调用epoll_process函数。主要有以下工作内容：
1) 获取定时器timer，用于传递给epoll_wait函数。
2) 后置处理标志
3) 多进程accept互斥
4) Epoll_process
5) 处理后置事件队列，包括accept后置事件
下面是两个函数的代码以及注释：
void
ngx_process_events_and_timers(ngx_cycle_t*cycle)//该函数在worker进程中loop
{
ngx_uint_t flags;//两个标识，一个是关于定时器的，另外一个则是关于accept post event的
ngx_msec_t timer, delta;
if (ngx_timer_resolution) {//如果定时器是否从新解决，初始值为0 这个应该是永远不会调用的
timer = NGX_TIMER_INFINITE;//-1,阻塞方式等待
flags = 0;
} else {//否则需要更新
timer = ngx_event_find_timer();//查找定时器，在epoll_wait之前更新定时器
flags = NGX_UPDATE_TIME;
#if (NGX_THREADS)//是否存在线程池
if (timer == NGX_TIMER_INFINITE || timer > 500) {//定时器大于500或者无限时设置为500
timer = 500;
}
#endif
}
//为什么需要在这里对accept进行互斥锁呢?
if (ngx_use_accept_mutex) {//如果使用accept互斥锁,只有在多进程的时候需要对accept进行互斥
if (ngx_accept_disabled > 0) {
ngx_accept_disabled--;
} else {
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;//如果一个工作进程没有获取到accept互斥锁，它将在最少在ngx_accept_mutex_delay毫秒后重新获取。这个值默认设置为500
}
}
}
}
delta = ngx_current_msec;//如果flags中有NGX_UPDATE_TIME，该变量会发生变化
(void) ngx_process_events(cycle, timer, flags);//如果调用epoll模块，则为ngx_epoll_process_events函数
delta = ngx_current_msec - delta;
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"timer delta: %M",delta);
if (ngx_posted_accept_events) {//在epoll模块中会把rev添加到ngx_posted_accept_events中
ngx_event_process_posted(cycle, &ngx_posted_accept_events);//处理ngx_posted_accept_events
}
if (ngx_accept_mutex_held) {
ngx_shmtx_unlock(&ngx_accept_mutex);//释放accept互斥锁
}
if (delta) {//当ngx_current_msec发生变化时，毁灭定时器
ngx_event_expire_timers();
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"posted events%p", ngx_posted_events);
if (ngx_posted_events) {//处理ngx_posted_events队列
if (ngx_threaded) {
ngx_wakeup_worker_thread(cycle);//使用线程处理
} else {
ngx_event_process_posted(cycle, &ngx_posted_events);//在进程中直接处理
}
}
}
static ngx_int_t
ngx_event_process_init(ngx_cycle_t *cycle)
{
…..
if (ccf->master && ccf->worker_processes > 1 &&ecf->accept_mutex) {//如果采用多进程且使用accept互斥锁
ngx_use_accept_mutex = 1;//在ngx_process_events_and_timer函数有用到
ngx_accept_mutex_held = 0;
ngx_accept_mutex_delay = ecf->accept_mutex_delay;
} else {
ngx_use_accept_mutex = 0;
}
……
if (ngx_event_timer_init(cycle->log) == NGX_ERROR) {//定时器初始化
return NGX_ERROR;
}
…………
cycle->connections =
ngx_alloc(sizeof(ngx_connection_t) * cycle->connection_n,cycle->log);//为connection分配空间
if (cycle->connections == NULL) {
return NGX_ERROR;
}
c = cycle->connections;
cycle->read_events = ngx_alloc(sizeof(ngx_event_t) *cycle->connection_n,
cycle->log);//初始化rev
if (cycle->read_events == NULL) {
return NGX_ERROR;
}
rev = cycle->read_events;
for (i = 0; i < cycle->connection_n; i++) {
rev[i].closed = 1;
rev[i].instance = 1;
#if (NGX_THREADS)
rev[i].lock = &c[i].lock;
rev[i].own_lock = &c[i].lock;
#endif
}
cycle->write_events = ngx_alloc(sizeof(ngx_event_t) * cycle->connection_n,
cycle->log);
if (cycle->write_events == NULL) {
return NGX_ERROR;
}
wev = cycle->write_events;
for (i = 0; i < cycle->connection_n; i++) {
wev[i].closed = 1;
#if (NGX_THREADS)
wev[i].lock = &c[i].lock;
wev[i].own_lock = &c[i].lock;
#endif
}
i = cycle->connection_n;
next = NULL;
do {
i--;
c[i].data = next;
c[i].read = &cycle->read_events[i];
c[i].write = &cycle->write_events[i];
c[i].fd = (ngx_socket_t) -1;
next = &c[i];
#if (NGX_THREADS)
c[i].lock = 0;
#endif
} while (i);
cycle->free_connections = next;
cycle->free_connection_n = cycle->connection_n;
/* for each listening socket */
ls = cycle->listening.elts;
for (i = 0; i < cycle->listening.nelts; i++) {//有侦听nelts个socket
c = ngx_get_connection(ls[i].fd, cycle->log);//获取listen后的connection数据信息
if (c == NULL) {
return NGX_ERROR;
}
c->log = &ls[i].log;
c->listening = &ls[i];
ls[i].connection = c;
rev = c->read;//把connection数据结构中的接受指针传给rev
rev->log = c->log;
rev->accept = 1;//设置accept位，在epoll_wait循环中会进行判定，从而调用accept处理函数
#if (NGX_HAVE_DEFERRED_ACCEPT)//延期的accept
rev->deferred_accept = ls[i].deferred_accept;
#endif
if (!(ngx_event_flags & NGX_USE_IOCP_EVENT)) {//iocp调用，win32?
if (ls[i].previous) {
/*
* delete the old accept eventsthat were bound to
* the old cycle read eventsarray
*/
old =ls[i].previous->connection;
if (ngx_del_event(old->read,NGX_READ_EVENT, NGX_CLOSE_EVENT)
== NGX_ERROR)
{
return NGX_ERROR;
}
old->fd = (ngx_socket_t) -1;
}
}
……..
rev->handler = ngx_event_accept;//设置rev handler为accept event
if (ngx_use_accept_mutex) {
continue;
}
if (ngx_event_flags & NGX_USE_RTSIG_EVENT) {//rtsig多路复用机制
if (ngx_add_conn(c) == NGX_ERROR) {
return NGX_ERROR;
}
} else {
if (ngx_add_event(rev, NGX_READ_EVENT, 0) == NGX_ERROR) {//添加事件到epoll队列中，将调用ngx_epoll_add_event函数
return NGX_ERROR;
}
}
#endif
}
return NGX_OK;
}
最后说明下，在event模块中还有两个接口，由于业务逻辑层添加读写事件之用。
ngx_int_tngx_handle_read_event(ngx_event_t *rev, ngx_uint_t flags);
ngx_int_tngx_handle_write_event(ngx_event_t *wev, size_t lowat);
两个函数中都封装了epoll_add_event函数，用于添加事件，其中handle_read_event中的epoll op参数是EPOLLIN,而handle_write_event为EPOLLOUT。