博客园  :: 首页  :: 新随笔  :: 联系 :: 订阅 订阅  :: 管理

Nginx的定时事件的实现（timer）

Posted on 2016-03-08 10:54  bw_0927  阅读(580)  评论(0)    收藏  举报

http://blog.csdn.net/fjslovejhl/article/details/8145134

 

在前面的文章里面就说到了在事件循环中除了要处理所有的从epoll中获取的事件之外，还要处理一些timer事件，这篇文章就讲讲Nginx的timer是如何实现的。

在讲Nginx的实现之前，我们可以先回顾一下linux的定时器的实现。在linux中通过每次系统定时器时钟的中断的中断处理程序来设置相应的软中断位，该软中断的中断处理程序目的就是为了扫描系统中所有挂起的定时器，如果他们已经超时的话，那么就调用他们相应的函数，这样说白了就是利用中断来实现定时器。

而在Nginx中，timer是自己实现的，而且实现的方法完全不同，而是通过红黑树来维护所有的timer节点，在worker进程的每一次循环中都会调用ngx_process_events_and_timers函数，在该函数中就会调用处理定时器的函数ngx_event_expire_timers，每次该函数都不断的从红黑树中取出时间值最小的，查看他们是否已经超时，然后执行他们的函数，直到取出的节点的时间没有超时为止。其实在Nginx的运行环境中，这种实现方式可能比linux本身的实现方式更为高效。

首先我们来看Nginx的定时器的初始化，在ngx_event_process_init函数中（ Ngx_event.c）：

[cpp] view plain copy
 
  1. /*初始化计时器，此处将会创建起一颗红黑色，来维护计时器。*/   
  2.    if (ngx_event_timer_init(cycle->log) == NGX_ERROR) {  
  3.        return NGX_ERROR;  
  4.    }  

嗯，就是这个函数，那么接下来我们来看这个函数吧，

[cpp] view plain copy
 
  1. //timer的初始化  
  2. ngx_int_t  
  3. ngx_event_timer_init(ngx_log_t *log)  
  4. {  
  5. //初始化红黑树  
  6.     ngx_rbtree_init(&ngx_event_timer_rbtree, &ngx_event_timer_sentinel,  
  7.                     ngx_rbtree_insert_timer_value);  
  8.   
  9. #if (NGX_THREADS)  
  10.   
  11.     if (ngx_event_timer_mutex) {  
  12.         ngx_event_timer_mutex->log = log;  
  13.         return NGX_OK;  
  14.     }  
  15.   
  16.     ngx_event_timer_mutex = ngx_mutex_init(log, 0);  
  17.     if (ngx_event_timer_mutex == NULL) {  
  18.         return NGX_ERROR;  
  19.     }  
  20.   
  21. #endif  
  22.   
  23.     return NGX_OK;  
  24. }  

 其实该函数非常的简单，说白了就是直接调用ngx_rbtree_init函数来初始化一颗红黑树而已（红黑树是Nginx自己实现的）。

 

接下来来看如何定义一个timer事件：

[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. }  

该函数用于将事件加入到红黑树中，首先设置超时时间，也就是当前的时间加上传进来的超时时间。然后再将timer域加入到红黑树中就可以了，这里timer域的定义说白了是一棵红黑树节点。然后还有一个函数ngx_event_del_timer，它用于将某个事件从红黑树当中移除。

 

接下来我们来看看Nginx到底是如何处理定时事件的。在ngx_process_events_and_timers函数中首先会有如下的代码：

[cpp] view plain copy
 
  1.     if (ngx_timer_resolution) {  
  2.         timer = NGX_TIMER_INFINITE;  
  3.         flags = 0;  
  4.   
  5.     } else {  
  6.         timer = ngx_event_find_timer();  //找到当前红黑树当中的最小的时间，传递给epoll的wait，保证epoll可以该时间内可以超时，可以使得超时的事件得到处理  
  7.         flags = NGX_UPDATE_TIME;  
  8.   
  9. #if (NGX_THREADS)  
  10.   
  11.         if (timer == NGX_TIMER_INFINITE || timer > 500) {  
  12.             timer = 500;  
  13.         }  
  14.   
  15. #endif  
  16.     }  

该段代码主要是调用ngx_event_find_timer函数获取当前红黑树中超时时间最小的一个节点，该函数的定义如下：

[cpp] view plain copy
 
  1. //用于返回当前红黑树当中的超时时间，说白了就是返回红黑树中最左边的元素的超时时间  
  2. ngx_msec_t  
  3. ngx_event_find_timer(void)  
  4. {  
  5.     ngx_msec_int_t      timer;  
  6.     ngx_rbtree_node_t  *node, *root, *sentinel;  
  7.   
  8.     if (ngx_event_timer_rbtree.root == &ngx_event_timer_sentinel) {  
  9.         return NGX_TIMER_INFINITE;  
  10.     }  
  11.   
  12.     ngx_mutex_lock(ngx_event_timer_mutex);  
  13.   
  14.     root = ngx_event_timer_rbtree.root;  
  15.     sentinel = ngx_event_timer_rbtree.sentinel;  
  16.   
  17.     node = ngx_rbtree_min(root, sentinel);  //找到红黑树中key最小的节点  
  18.   
  19.     ngx_mutex_unlock(ngx_event_timer_mutex);  
  20.   
  21.     timer = (ngx_msec_int_t) (node->key - ngx_current_msec);  
  22.   
  23.     return (ngx_msec_t) (timer > 0 ? timer : 0);  
  24. }  

该函数其实还是很简单的，说白了就是找到红黑树中key的值最小的节点，然后返回它还剩下的超时时间就可以了。在ngx_process_events_and_timers函数中之所以要获取这个值，是为了为epoll的wait提供一个超时时间，以防止epoll的wait阻塞时间太长，影响了timer的处理。接着或有如下的代码：

[cpp] view plain copy
 
  1. /*delta是上文对epoll wait事件的耗时统计，若存在毫秒级的耗时  
  2.     就对所有事件的timer进行检查，如果time out就从timer rbtree中，  
  3.     删除到期的timer，同时调用相应事件的handler函数完成处理。  
  4.   */    
  5.    if (delta) {  
  6.        ngx_event_expire_timers();  
  7.    }  

在ngx_process_events_and_timers函数中调用ngx_event_expire_timers函数来处理所有的定时事件。嗯，这里可以看到一个比较奇怪的现象，干嘛要判断delta的值呢，嗯，其实这个值是统计处理其余事件的用时，如果用时超过了毫秒，那么才会真正的调用ngx_event_expire_timers函数来处理所有的定时，否则不会，因为距离上次循环间隔太小，完全没有必要。嗯，性能的提升也就是从这一点一滴中获取的吧。接下来来看ngx_event_expire_timers函数吧：

[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.   
  30.   
  31.             ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,  
  32.                            "event timer del: %d: %M",  
  33.                            ngx_event_ident(ev->data), ev->timer.key);  
  34. //将当前timer移除  
  35.             ngx_rbtree_delete(&ngx_event_timer_rbtree, &ev->timer);  
  36.   
  37.             ngx_mutex_unlock(ngx_event_timer_mutex);  
  38.   
  39.   
  40.             ev->timer_set = 0;  
  41.   
  42.   
  43.   
  44.             ev->timedout = 1;  
  45.   
  46.             ev->handler(ev);   //调用event的handler来处理这个事件  
  47.   
  48.             continue;  
  49.         }  
  50.   
  51.         break;  
  52.     }  
  53.   
  54.     ngx_mutex_unlock(ngx_event_timer_mutex);  
  55. }  

该函数其实很简单的，一看就看明白了，说白了就是一个死循环，不断的从红黑树中获取key最小的元素，如果超时的话，就通过偏移量来获取其所在的event，然后执行handler，直到找到一个没有超时的timer为止，跳出循环。

 

嗯，到这里timer就讲完了。