Libev中的超时监视器ev_timer，就是简单的相对时间定时器，它会在给定的时间点触发超时事件，还可以在固定的时间间隔之后再次触发超时事件。

所谓的相对时间，指的是如果你注册了一个1小时的超时事件，然后调整系统时间到了去年的一月份，该超时事件依然会在1个小时之后触发。

 

一：数据结构

1：超时监视器ev_timer结构：

typedef struct ev_timer

{

    int active;

    int pending;

    int priority;

    void *data;

    void (*cb)(struct ev_loop *loop, struct ev_timer *w, int revents);  

    ev_tstamp at;

    ev_tstamp repeat; /* rw */

} ev_timer;

其中的前五个成员是监视器的公共成员，其中的active在超时监视器中有特殊作用，那就是标明该监视器在堆数组timers中的下标。后两个成员at和repeat是ev_timer特有的。at表明定时器第一次触发的时间点，该是是根据mn_now设置的，repeat必须大于等于0，它表示每隔repeat秒，该定时器再次触发。如果repeat为0，表明该定时器只触发一次。

2：ev_watcher_time结构

typedef struct ev_watcher_time

{

    int active;

    int pending;

    int priority;

    void *data;

    void (*cb)(struct ev_loop *loop, struct ev_watcher_time *w, int revents);  

    ev_tstamp at;

} ev_watcher_time;

typedef ev_watcher_time *WT;

ev_watcher_time的结构与ev_timer几乎一样，只是少了最后一个成员。该结构其实是ev_timer和ev_periodic的父类，它包含了ev_timer和ev_periodic的共有成员。

3：堆元素ANHE

#if EV_HEAP_CACHE_AT

    typedef struct

    {

        ev_tstamp at;

        WT w;

    } ANHE;

#else

typedef WT ANHE;

#endif

宏EV_HEAP_CACHE_AT的作用，是为了提高在堆中的缓存利用率，如果没有定义该宏，堆元素就是指向ev_watcher_time结构的指针。如果定义了该宏，则还将堆元素的关键成员at进行缓存。

二：超时监视器函数

1：设置超时监视器ev_timer_set

#define ev_timer_set(ev, after_, repeat_)      do {\

    ((ev_watcher_time *)(ev))->at = (after_); \

    (ev)->repeat = (repeat_); \

} while (0)

2：启动超时监视器ev_timer_start

#if EV_HEAP_CACHE_AT

  #define ANHE_w(he)        (he).w

  #define ANHE_at(he)       (he).at

  #define ANHE_at_cache(he) (he).at = (he).w->at

#else

  #define ANHE_w(he)        (he)

  #define ANHE_at(he)       (he)->at

  #define ANHE_at_cache(he)

#endif

void ev_timer_start (struct ev_loop *loop, ev_timer *w)

{

    if (expect_false (ev_is_active (w)))

        return;

    ev_at (w) += mn_now;

    assert (("libev: ev_timer_start called with negative timer repeat value", w->repeat >= 0.));

    ++timercnt;

    ev_start (EV_A_ (W)w, timercnt + HEAP0 - 1);

    array_needsize (ANHE, timers, timermax, ev_active (w) + 1, EMPTY2);

    ANHE_w (timers [ev_active (w)]) = (WT)w;

    ANHE_at_cache (timers [ev_active (w)]);

    upheap (timers, ev_active (w));

}

代码比较简单，首先设置监视器的at成员，表明在at时间点，超时事件会触发，注意at是根据mn_now设置的，也就是相对于系统启动时间而言的（或者是日历时间）。之后，就是将该监视器加入到堆timer中，首先将该监视器加到堆中的最后一个元素，然后调用upheap调整堆。注意监视器的active成员，表明该监视器在堆数组中的下标。

3：停止超时监视器ev_timer_stop

void ev_timer_stop (EV_P_ ev_timer *w) EV_THROW

{

    clear_pending (EV_A_ (W)w);

    if (expect_false (!ev_is_active (w)))

        return;

    int active = ev_active (w);

    --timercnt;

    if (expect_true (active < timercnt + HEAP0))

    {

        timers [active] = timers [timercnt + HEAP0];

        adjustheap (timers, timercnt, active);

    }

    ev_at (w) -= mn_now;

    ev_stop (EV_A_ (W)w);

}

首先调用clear_pending，如果该监视器已经处于pending状态，将其从pendings中删除。然后根据监视器中的active成员，得到其在timers堆上的索引，将该监视器从堆timers上删除，重新调整堆结构。然后调用ev_stop停止该监视器。

4：timers_reschedule更新定时器的时间

在ev_run中，每次loop中，在调用backend_poll前后都会调用time_update更新当前时间，如果发现时间被人调整，则需要更新定时器，更新相对定时器时，调用timers_reschedule(loop, ev_rt_now - mn_now)，其中，ev_rt_now是最新的当前日历时间，mn_now是之前记录的日历时间，他们之间的差值就表示时间调整了多少，timers_reschedule代码如下：

static void timers_reschedule (struct ev_loop *loop, ev_tstamp adjust)

{

    int i;

    for (i = 0; i < timercnt; ++i)

    {

        ANHE *he = timers + i + HEAP0;

        ANHE_w (*he)->at += adjust;

        ANHE_at_cache (*he);

    }

}

代码较简单，就是更新堆timers中的每个元素的at值。

5：timers_reify将激活的超时事件排队

每次调用backend_poll之前，都会根据ANHE_at (timers [HEAP0]) - mn_now的值，校准backend_poll的阻塞时间waittime，这样就能尽可能的保证定时器能够按时触发。

调用backend_poll之后，就会调用timers_reify查看timers中哪些定时器触发了，代码如下：

void timers_reify(struct ev_loop *loop)

{

    if (timercnt && ANHE_at (timers [HEAP0]) < mn_now)

    {

        do

        {

            ev_timer *w = (ev_timer *)ANHE_w (timers [HEAP0]);

            /* first reschedule or stop timer */

            if (w->repeat)

            {

                ev_at (w) += w->repeat;

                if (ev_at (w) < mn_now)

                    ev_at (w) = mn_now;

                ANHE_at_cache (timers [HEAP0]);

                downheap (timers, timercnt, HEAP0);

            }

            else

                ev_timer_stop (EV_A_ w); /* nonrepeating: stop timer */

            feed_reverse (EV_A_ (W)w);

        }

        while (timercnt && ANHE_at (timers [HEAP0]) < mn_now);

        feed_reverse_done (loop, EV_TIMER);

    }

}
void feed_reverse (struct ev_loop *loop, W w)

{

    array_needsize (W, rfeeds, rfeedmax, rfeedcnt + 1, EMPTY2);

    rfeeds [rfeedcnt++] = w;

}

void feed_reverse_done (struct ev_loop *loop, int revents)

{

    do

        ev_feed_event (EV_A_ rfeeds [--rfeedcnt], revents);

    while (rfeedcnt);

}


如果堆顶元素的超时时间点at小于mn_now（是小于，而不是等于，原因见：http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod#The_special_problem_of_being_too_ear），说明堆顶元素的超时时间到时，进入循环，取出堆顶元素的监视器，如果w->repeat大于0，则设置该超时监视器下一次触发的时间点，然后调用downheap调整堆结构。否则，直接调用ev_timer_stop停止该监视器。最后，调用feed_reverse将该监视器放入rfeeds数组中，该数组对当前已经触发的超时监视器缓存。然后，继续查看新的堆顶元素是否已经超时，超时的话接着上面的步骤进行处理。


将所有本次触发的超时事件都处理完之后，调用feed_reverse_done，将缓存数组rfeeds中每个元素通过ev_feed_event添加到pendings数组中。


三：例子


void timer_action(struct ev_loop *main_loop,ev_timer *timer_w,int e)

{

    time_t now;

    now = time(NULL);

    printf("in tiemr cb%d , cur time is %s\n", (int)(timer_w->data), ctime(&now));

}

int main(int argc ,char *argv[])

{

    struct ev_loop *main_loop = ev_default_loop(0);

    timer_w1.data = (void *)1;

    ev_init(&timer_w1,timer_action);

    ev_timer_set(&timer_w1,10,5);

    ev_timer_start(main_loop,&timer_w1);

    timer_w2.data = (void *)2;

    ev_init(&timer_w2,timer_action);

    ev_timer_set(&timer_w2,5,10);

    ev_timer_start(main_loop,&timer_w2);

    time_t now;

    now = time(NULL);

    printf("begin time time is %s\n", ctime(&now));

    ev_run(main_loop,0);

    return;

}




结果打印：


begin time time is Wed Oct 21 21:55:31 2015


in tiemr cb2 , cur time is Wed Oct 21 21:55:36 2015


in tiemrcb1 , cur time is Wed Oct 21 21:55:41 2015


in tiemrcb1 , cur time is Wed Oct 21 21:55:46 2015


in tiemr cb2 , cur time is Wed Oct 21 21:55:46 2015


in tiemrcb1 , cur time is Wed Oct 21 21:55:51 2015


in tiemrcb1 , cur time is Wed Oct 21 21:55:56 2015


in tiemr cb2 , cur time is Wed Oct 21 21:55:56 2015


in tiemrcb1 , cur time is Wed Oct 21 21:56:01 2015


...
												


																

最新文章
	

    
						
  1. 【目录】C#操作Excel组件Spire.XLS系列文章目录
		
    2. 
						
  2. 纯js制作遮罩层对话框 -- g皓皓
		
    3. 
						
  3. 常用排序算法之——快速排序（C语言+VC6.0平台）
		
    4. 
						
  4. .NET MD5加密解密代码
		
    5. 
						
  5. [leetcode-521-Longest Uncommon Subsequence I]
		
    6. 
						
  6. Mysql介绍和实践总结
		
    7. 
						
  7. 分析 ajax 请求并抓取今日头条街拍美图
		
    8. 
						
  8. 禁用 Chrome 的黑色模式/Dark Mode
		
    9. 
						
  9. [加密解密]CryptoAPI简介
		
    10. 
						
  10. 基于ZYNQ的双核启动与通信问题解决
		
    11. 
						
  11. ISNUMERIC使用说明和BUG
		
    12. 
						
  12. GIS小知识
		
    13. 
						
  13. file 文件处理
		
    14. 
						
  14. org.apache.jasper.JasperException: /WEB-INF/view/../../../common/common1.jsp (line: 7, column: 1) Page directive must not have multiple occurrences of pageencoding
		
    15. 
						
  15. 对 Kotlin 与 Java 编程语言的思考
		
    16. 
						
  16. Java之Spring Boot学习
		
    17. 
						
  17. [GDAL]在三维场景中显示DEM
		
    18. 
						
  18. JS中函数void()
		
    19. 
						
  19. Siki_Unity_2-1_API常用方法和类详细讲解(下)
		
    20. 
						
  20. LeetCode：N叉树的后序遍历【590】
		
    21. 
		

	


热门文章
	

    
									
  1. Birt设置导出格式和去掉多余按钮的方法
			
    2. 
						
  2. Linux部署教育云平台测试环境总结
			
    3. 
						
  3. union /union all/ intersect / minus
			
    4. 
						
  4. nginx源码分析线程池详解
			
    5. 
						
  5. 优化 Tengine HTTPS 握手时间
			
    6. 
						
  6. MaxCompute问答整理之7月
			
    7. 
						
  7. PHP 学习1.3
			
    8. 
						
  8. WPF 如何显示gif
			
    9. 
						
  9. unity如何查找某个脚本挂在了哪些物体上
			
    10. 
						
  10. 使用Git Bash进行代码管理
			
    11.