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();                                             
    }
    /* 省略了延後事件的處理 */
}                                                                              
複製代碼