Nginx 超时事件的处理机制

本文基于Nginx 0.8.55源代码，并基于epoll机制分析

对于nginx而言，事件机制的处理无非就是几个部分：

• 网络IO事件的处理
• 文件IO事件的处理
• 定时器事件的处理

（固然还有许多其余的不过我如今并非很关心。。）
我在读Nginx定时器事件相关的代码时看到了不少有趣的设计和考量，感受仍是值得写一写的，固然大佬们可能司空见惯了……嘛。

1. nginx的时间缓存

首先，因为较早期的Linux中，gettimeofday()自己是一个系统调用，对它的频繁调用会有比较大的开销，所以，Nginx采用了在本地缓存时间的作法。

Nginx是用几个全局变量来缓存时间的：

volatile ngx_msec_t      ngx_current_msec;                                        
volatile ngx_time_t     *ngx_cached_time;                                         
volatile ngx_str_t       ngx_cached_err_log_time;                                 
volatile ngx_str_t       ngx_cached_http_time;                                    
volatile ngx_str_t       ngx_cached_http_log_time;                                
复制代码

从命名和类型也能看出来，Nginx给各个模块提供了各类类型的缓存变量，以供其余须要调用ngx_time()和ngx_timeofday()的模块提供当前时间，从而避免了gettimeofday()等系统调用的开销（固然，较新版本的Linux中gettimeofday()已经不是传统意义上的系统调用了，可是比较新的Nginx源码我也没看……）

Nginx还提供了几个队列来缓存时间的更新历史：

static ngx_time_t        cached_time[NGX_TIME_SLOTS];                             
static u_char            cached_err_log_time[NGX_TIME_SLOTS]                      
                                    [sizeof("1970/09/28 12:00:00")];              
static u_char            cached_http_time[NGX_TIME_SLOTS]                         
                                    [sizeof("Mon, 28 Sep 1970 06:00:00 GMT")];    
static u_char            cached_http_log_time[NGX_TIME_SLOTS]                     
                                    [sizeof("28/Sep/1970:12:00:00 +0600")];       
复制代码

事实上上面那些缓存变量的实际值最终都指向了这些队列中的值，不过我grep了一下源码，这些队列好像也没在别处派上用场…因此对他们也不详细介绍了，简而言之就是Nginx维护了一个slot全局变量，每次在ngx_time_update函数中调用gettimeofday()获取当前时间，在队列后插入新时间而后移动slot来指示当前缓存值，而且把ngx_cache_time等指针指向最新的cache_time[slot]就好了。

具体能够看ngx_time_update()的实现便可。

2. Nginx什么时候更新缓存

这里咱们主要关注的问题是，Nginx更新时间缓存的时机是何时呢？

固然初启动和cycle的初始化有几回更新的时机，这里咱们主要考虑事件处理过程当中时间更新的时机。

这里Nginx给出了两种不一样的解决方案，由ngx_time_resolution变量决定：

• 在ngx_timer_resolution为0的时候，Nginx会在每次调用epoll_wait后进行一次时间缓存的更新
• 在ngx_timer_resolution不为0的时候，这个值表明着时间精度，即“多长时间更新一次缓存”，这时候Nginx会在时间模块初始化的时候设置定时器，让定时器的中断时间为ngx_timer_resolution规定的毫秒数，每触发一次SIGALRM信号，就调用一次ngx_time_update()。

固然，咱们断然不会容许信号处理函数自己占用过多的CPU时间，因此其信号处理函数的实现很是简单：

void ngx_timer_signal_handler(int signo) {                                                                                  
    ngx_event_timer_alarm = 1;                                                     
                                                                                   
#if 1 
    ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ngx_cycle->log, 0, "timer signal");    
#endif 
}                                                                                  
复制代码

而真正调用ngx_time_update()则是在ngx_process_events()中：

static ngx_int_t ngx_epoll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer, ngx_uint_t flags) {                                                                                 
    int                events;                                                    
    uint32_t           revents;                                                   
    ngx_int_t          instance, i;                                               
    ngx_uint_t         level;                                                     
    ngx_err_t          err;                                                       
    ngx_log_t         *log;                                                       
    ngx_event_t       *rev, *wev, **queue;                                        
    ngx_connection_t  *c;                                                         
                                                                                  
    /* NGX_TIMER_INFINITE == INFTIM */                                            
                                                                                  
    ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,                            
                   "epoll timer: %M", timer);                                     
                                                                                  
    // 调用epoll_wait 
    events = epoll_wait(ep, event_list, (int) nevents, timer);                    
                                                                                  
    err = (events == -1) ? ngx_errno : 0;                                         
                                                                                  
    // 这里时更新时间的时机之一 
    // 若是SIGALRM的回调函数被调用，那么ngx_event_timer_alarm设为1，此时更新时间
    if (flags & NGX_UPDATE_TIME || ngx_event_timer_alarm) {                       
        ngx_time_update();                                                        
    }                                                                             
                                                                                  
    if (err) {                                                                    
        if (err == NGX_EINTR) {                                                   
                                                                                  
            // 若是是被时钟中断，那么返回NGX_OK 
            if (ngx_event_timer_alarm) {                                          
                ngx_event_timer_alarm = 0;                                        
                return NGX_OK;                                                    
            }                                                                     
                                                                                  
            level = NGX_LOG_INFO;                                                 
                                                                                  
        } else {                                                                  
            level = NGX_LOG_ALERT;                                                
        }                                                                         
                                                                                  
        ngx_log_error(level, cycle->log, err, "epoll_wait() failed");             
        return NGX_ERROR;                                                         
    }
    /* 省略处理事件的代码 */
}

复制代码

这里咱们能够看到，函数中首先会检查一下flag参数的NGX_UPDATE_TIME标志位，这是ngx_timer_resolution为0的时候才会设置的位，表示每次事件处理都会更新时间缓存。而这以外的状况则是ngx_timer_resolution不为0，由软中断设置标志位才会触发时间缓存的更新。

这里也处理了当epoll_wait被信号中断的状况，若是错误正好是EINTR且ngx_event_timer_alarm正好为1，那么就认为是该信号中断了epoll_wait，并把ngx_event_timer_alarm清0。

3. 定时事件的组织方式

对于定时事件，或者超时事件的处理，咱们有一个很是简单的直觉：给每一个定时事件注册一个定时器，在定时器回调中去处理过时事件不就行了？代码写起来多简单，要是再有个lambda表达式……

惋惜不行 ，系统底层提供的定时器数量肥肠有限，不过咱们却是能够把API设计成这样……扯远了。

Nginx这里采用了一个很简单而有效的策略：选择一个合适的时机，尽量地检查最近要过时的事件是否是已通过期，有的话就处理，没有的话就跳过。

那么维护一个能够很快取得“最近要过时的结构”就显得很重要了，并且在繁复的事件处理过程当中，定时事件会随机地插入，因此简单的队列也没法胜任——这个时候熟悉数据结构的同窗可能很快就想到了红黑树。

没错，Nginx就是采用红黑树来管理定时事件（或者咱们叫他超时事件）。以到期时间为key管理这颗红黑树，那么红黑树中最左边的事件就是即将超期的事件。而当事件的消费者要插入事件，消费完以后要删除事件，包括寻找即将超期的事件，这些操做的时间复杂度都控制在O(logN)内，效率是至关高的。（关于红黑树这种数据结构的细节，请参考数据结构的专著）

这是Nginx管理超时事件的基调。具体的代码实现能够参照src/event/ngx_event_timer.c的三个函数，基本上就是一些红黑树的增删改查而后调回调啊之类的。

4. 处理定时事件的时机

超时事件的处理时机，固然仍是放在大的事件循环中，为了减小accept锁的占用时间，超时事件的处理固然仍是放在释放accept锁的时机以后。

为了防止不开启timer_resolution的状况下，epoll_wait()占用太多时间，在调用ngx_process_events(cycle, timer, flags)以前，Nginx会先计算距离最近超时事件的时间，而后把这个时间记录在timer变量中传给epoll_wait的超时参数，来控制epoll_wait的占用时长。

此外，Nginx还会计算ngx_process_events调用所占用的时长（delta变量）,惟有delta > 0的状况，才会调用ngx_event_expire_timers()来处理超时事件，以此来避免无心义的搜索（真是煞费苦心啊）。

下面能够总体看看在事件循环中超时事件处理所占的位置：

void ngx_process_events_and_timers(ngx_cycle_t *cycle) {                                                                              
    ngx_uint_t  flags;                                                         
    ngx_msec_t  timer, delta;                                                  
                                                                               
    if (ngx_timer_resolution) {                                                
        timer = NGX_TIMER_INFINITE;                                            
        flags = 0;                                                             
                                                                               
    } else {                                                                   
        // 把距离最近的超时事件的时间记录在timer中 
        timer = ngx_event_find_timer();                                        
        flags = NGX_UPDATE_TIME;                                               
    }                                                                          
                                                                               
    // 这里是处理负载均衡锁和accept锁的时机 
	/* 省略了accept锁的竞争 */                                                                               
    delta = ngx_current_msec;                                                  
                                                                               
    // 调用事件处理模块的process_events，处理一个epoll_wait的方法 
    (void) ngx_process_events(cycle, timer, flags);                            
delta = ngx_current_msec - delta; //计算处理events事件所消耗的时间 
                                                                               
    // 若是有延后处理的accept事件，那么延后处理这个事件 
    if (ngx_posted_accept_events) {                                            
        ngx_event_process_posted(cycle, &ngx_posted_accept_events);            
    }                                                                          
                                                                               
    // 释放accept锁 
    if (ngx_accept_mutex_held) {                                               
        ngx_shmtx_unlock(&ngx_accept_mutex);                                   
    }                                                                          
                                                                               
    // 处理全部的超时事件 
    if (delta) {                                                               
        ngx_event_expire_timers();                                             
    }
    /* 省略了延后事件的处理 */
}                                                                              
复制代码