nginx的定时器

在nginx中有两种事件类型，其中一种的引发点是epoll，也就是通过epoll来获取事件的源头，另外一种就是定时时间。。在前面的代码中就已经遇到过了，例如当nginx获取到一个客户端的连接时，需要对该连接进行初始化，同时还要给这个连接增加一个定时器，如果都超时了请求的数据都还没有接收完整，那么就直接断开这个连接。。。

这里，nginx中的定时功能并没有采用操作系统提供的定时器，而是自己实现了一个模拟定时器的方法。。。最核心的就是一颗红黑树。。。。

在Ngx_times.c文件中定义了很多关于时间的全局变量，其中对于定时时间最为重要的是：

[cpp] view plain copy

1. volatile ngx_msec_t      ngx_current_msec;  

ngx_msec_t为一个无符号的整形，用于代表当前的UTC时间，单位是毫秒。。

我们首先来看添加定时事件的函数吧：

[cpp] view plain copy

1. //将一个事件加入到红黑树当中，它的超时未timer时间  
2. static ngx_inline void  
3. ngx_event_add_timer(ngx_event_t *ev, ngx_msec_t timer)   //timer说白了就是一个int的值，表示超时的事件，用于表示红黑树节点的key  
4. {  
5.     ngx_msec_t      key;  
6.     ngx_msec_int_t  diff;  
7.   
8.     key = ngx_current_msec + timer;  //表示该event的超时时间，为当前时间的值加上超时变量  
9.   
10.     if (ev->timer_set) {  
11.   
12.         /* 
13.          * Use a previous timer value if difference between it and a new 
14.          * value is less than NGX_TIMER_LAZY_DELAY milliseconds: this allows 
15.          * to minimize the rbtree operations for fast connections. 
16.          */  
17.   
18.         diff = (ngx_msec_int_t) (key - ev->timer.key);  
19.   
20.         if (ngx_abs(diff) < NGX_TIMER_LAZY_DELAY) {  
21.             ngx_log_debug3(NGX_LOG_DEBUG_EVENT, ev->log, 0,  
22.                            "event timer: %d, old: %M, new: %M",  
23.                             ngx_event_ident(ev->data), ev->timer.key, key);  
24.             return;  
25.         }  
26.   
27.         ngx_del_timer(ev);  
28.     }  
29.   
30.     ev->timer.key = key;  
31.   
32.     ngx_log_debug3(NGX_LOG_DEBUG_EVENT, ev->log, 0,  
33.                    "event timer add: %d: %M:%M",  
34.                     ngx_event_ident(ev->data), timer, ev->timer.key);  
35.   
36.     ngx_mutex_lock(ngx_event_timer_mutex);  
37.   
38.     ngx_rbtree_insert(&ngx_event_timer_rbtree, &ev->timer);    //事件的timer域插入到红黑树当中  
39.   
40.     ngx_mutex_unlock(ngx_event_timer_mutex);  
41.   
42.     ev->timer_set = 1;  
43. }  

代码其实还是比较的简单，核心就是将当前event的timer插入到事件红黑树当中，其超时时间为当前的时间加上传进来的超时时间。。。

我们接着来看ngx_process_events_and_timers函数，

[html] view plain copy

1. timer = ngx_event_find_timer();   

这里用于获取当前事件红黑树中最小的超时时间（也就是红黑树中最左边的节点），将其提供给epoll，让epoll的wait在这个时间内唤醒。。。

接下来再来看ngx_epoll_process_events函数，

[html] view plain copy

1. events = epoll_wait(ep, event_list, (int) nevents, timer);    //这个超时事件是从红黑树里面获取的，当前最近的超时，这样可以保证epoll的wait能够在合适的时间内返回，保证定义的超时事件可以执行  
2.   
3.  err = (events == -1) ? ngx_errno : 0;  
4.   
5.  if (flags & NGX_UPDATE_TIME || ngx_event_timer_alarm) {  
6.      ngx_time_update();  
7.  }  
8.   
9.  if (err  

每一次wait之后就会调用ngx_time_updateh函数来更新当前的与时间相关的全局变量。。。

接下来回到ngx_process_event_and_timers中，

[html] view plain copy

1. if (delta) {  
2.     ngx_event_expire_timers();  
3. }  

这部分代码用于处理所有的超时时间。。来看看它的代码吧：

[cpp] view plain copy

1. //处理红黑树中所有超时的事件  
2. void  
3. ngx_event_expire_timers(void)  
4. {  
5.     ngx_event_t        *ev;  
6.     ngx_rbtree_node_t  *node, *root, *sentinel;  
7.   
8.     sentinel = ngx_event_timer_rbtree.sentinel;  
9.   
10. //死循环，找到所有的超时的timer，然后处理他们  
11.     for ( ;; ) {  
12.   
13.         ngx_mutex_lock(ngx_event_timer_mutex);  
14.   
15.         root = ngx_event_timer_rbtree.root;  
16.   
17.         if (root == sentinel) {  
18.             return;  
19.         }  
20.   
21.         node = ngx_rbtree_min(root, sentinel);   //获取key最小的节点  
22.   
23.         /* node->key <= ngx_current_time */  
24.   
25.         if ((ngx_msec_int_t) (node->key - ngx_current_msec) <= 0) {   //判断该节点是否超时，如果超时的话，就执行处理函数，否则就可以跳出循环了  
26.             //通过偏移来获取当前timer所在的event  
27.             ev = (ngx_event_t *) ((char *) node - offsetof(ngx_event_t, timer));  
28.   
29. #if (NGX_THREADS)  
30.   
31.             if (ngx_threaded && ngx_trylock(ev->lock) == 0) {  
32.   
33.                 /* 
34.                  * We cannot change the timer of the event that is being 
35.                  * handled by another thread.  And we cannot easy walk 
36.                  * the rbtree to find next expired timer so we exit the loop. 
37.                  * However, it should be a rare case when the event that is 
38.                  * being handled has an expired timer. 
39.                  */  
40.   
41.                 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ev->log, 0,  
42.                                "event %p is busy in expire timers", ev);  
43.                 break;  
44.             }  
45. #endif  
46.   
47.             ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,  
48.                            "event timer del: %d: %M",  
49.                            ngx_event_ident(ev->data), ev->timer.key);  
50. //将当前timer移除  
51.             ngx_rbtree_delete(&ngx_event_timer_rbtree, &ev->timer);  
52.   
53.             ngx_mutex_unlock(ngx_event_timer_mutex);  
54.   
55. #if (NGX_DEBUG)  
56.             ev->timer.left = NULL;  
57.             ev->timer.right = NULL;  
58.             ev->timer.parent = NULL;  
59. #endif  
60.   
61.             ev->timer_set = 0;  
62.   
63. #if (NGX_THREADS)  
64.             if (ngx_threaded) {  
65.                 ev->posted_timedout = 1;  
66.   
67.                 ngx_post_event(ev, &ngx_posted_events);  
68.   
69.                 ngx_unlock(ev->lock);  
70.   
71.                 continue;  
72.             }  
73. #endif  
74.   
75.             ev->timedout = 1;  
76.   
77.             ev->handler(ev);   //调用event的handler来处理这个事件  
78.   
79.             continue;  
80.         }  
81.   
82.         break;  
83.     }  
84.   
85.     ngx_mutex_unlock(ngx_event_timer_mutex);  
86. }  

其实还是很简单的，说白了就是不断的从红黑树中获取key值最小的节点，然后判断它是否已经超时，如果超时的话就将其从红黑树中删除，然后调用处理函数。。。

这样子nginx的定时时间处理也就ok了。。。。