Chinaunix首页 | 论坛 | 博客

xiaqian369的ChinaUnix博客

首页　| 　博文目录　| 　关于我

xiaqian369

  • 博客访问： 391637
  • 博文数量： 80
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 560
  • 用 户 组： 普通用户
  • 注册时间： 2015-03-10 08:38
文章分类

全部博文（80）

文章存档

2016年（32）

2015年（48）

我的朋友
最近访客
推荐博文
相关博文
linux下多定时器的实现（经典）

分类： LINUX

2015-08-21 10:23:24

linux下多定时器的实现
一、已有的定时器接口
   时空管理是计算机系统的主要任务。在时间管理中，我们经常利用定时器处理事情：比如tcp协议中利用定时器管理包超时，视频显示中利用定时器来定时显示视频帧，web服务中利用定时器来管理用户的超时。windows系统提供了SetTimer和timeSetEvent等定时器接口，linux中则提供了setitimer等接口。这些函数的接口很类似，大体上都是用户提供回调函数和超时时间向OS注册一个定时器事件，OS在超时时间到了的时候，调用用户提供的回调函数来完成用户想要做的事情。windows下的接口支持单进程中拥有多个定时器，而linux则只允许单进程拥有一个定时器，因此在linux下的单进程中要使用多个定时器，则需要自己维护管理，这是本文写作的出发点。另外，OS提供的定时器管理算法在大规模定时器的管理方面可能还不尽人意，这时候就需要用户去优化管理算法了，本文在这方面提供了一点素材。

二、一个最简单的多定时器的实现（linux版）
1、实现细节 
  这个实现允许用户使用多个自定义的定时器，每个自定义的定时器将周期地被触发直到其被删除。实现的主要思路是：
    i）首先在初始化多定时器（init_mul_timer）时利用setitimer注册一个基本的时间单位（如1s）的定时事件；
    ii）用户需要set_a_timer注册自定义定时器时，在timer_manage管理结构中记录这个定时器的回调函数和定时周期等参数；
    iii）当基本的时间单位到期后（如SIGALRM信号到达时），遍历整个timer_manage，如果有自定义定时器的超时时间到了，就执行相应的回调函数，并将自定义定时器的超时时间置为最初值；否则将自定义定时器的超时时间相应地减一个基本的时间单位；
    iv）用户通过del_a_timer来删除某个定时器，通 过destroy_mul_timer来删除整个多定时器。
2、代码
i) mul_timer.h

  1. /* This file provides an interface of multiple timers. for convenience, it simplify signal processing.
  2.  * Also, it can't be used in multithreading environment.
  3.  * Author:bripengandre
  4.  * Date:2009-04-29
  5.  */
  6. #ifndef _MUL_TIMER_H_
  7. #define _MUL_TIMER_H_

  9. #include <sys/time.h>

  11. #define MAX_TIMER_CNT 10
  12. #define MUL_TIMER_RESET_SEC 10
  13. #define TIMER_UNIT 60
  14. #define MAX_FUNC_ARG_LEN 100
  15. #define INVALID_TIMER_HANDLE (-1)

  17. typedef int timer_handle_t;

  19. typedef struct _timer_manage
  20. {
  21.     struct _timer_info
  22.     {
  23.         int state; /* on or off */
  24.         int interval;
  25.         int elapse; /* 0~interval */
  26.         int (* timer_proc) (void *arg, int arg_len);
  27.         char func_arg[MAX_FUNC_ARG_LEN];
  28.         int arg_len;
  29.     }timer_info[MAX_TIMER_CNT];

  31.     void (* old_sigfunc)(int);
  32.     void (* new_sigfunc)(int);
  33.     struct itimerval value, ovalue;
  34. }_timer_manage_t;

  36. /* success, return 0; failed, return -1 */
  37. int init_mul_timer(void);
  38. /* success, return 0; failed, return -1 */
  39. int destroy_mul_timer(void);
  40. /* success, return timer handle(>=0); failed, return -1 */
  41. timer_handle_t set_a_timer(int interval, int (* timer_proc) (void *arg, int arg_len), void *arg, int arg_len);
  42. /* success, return 0; failed, return -1 */
  43. int del_a_timer(timer_handle_t handle);

  45. #endif /* _MUL_TIMER_H_ */

ii)mul_timer.c

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <signal.h>
  4. #include <time.h>
  5. #include "mul_timer.h"

  7. static struct _timer_manage timer_manage;

  9. static void sig_func(int signo);

  11. /* success, return 0; failed, return -1 */
  12. int init_mul_timer(void)
  13. {
  14.     int ret;
  15.     
  16.     memset(&timer_manage, 0, sizeof(struct _timer_manage));
  17.     if( (timer_manage.old_sigfunc = signal(SIGALRM, sig_func)) == SIG_ERR)
  18.     {
  19.         return (-1);
  20.     }
  21.     timer_manage.new_sigfunc = sig_func;
  22.     
  23.     timer_manage.value.it_value.tv_sec = MUL_TIMER_RESET_SEC;
  24.     timer_manage.value.it_value.tv_usec = 0;
  25.     timer_manage.value.it_interval.tv_sec = TIMER_UNIT;
  26.     timer_manage.value.it_interval.tv_usec = 0;
  27.     ret = setitimer(ITIMER_REAL, &timer_manage.value, &timer_manage.ovalue);
  28.     
  29.     return (ret);
  30. }


  33. /* success, return 0; failed, return -1 */
  34. int destroy_mul_timer(void)
  35. {
  36.     int ret;
  37.     
  38.     if( (signal(SIGALRM, timer_manage.old_sigfunc)) == SIG_ERR)
  39.     {
  40.         return (-1);

  42.     }

  44.     ret = setitimer(ITIMER_REAL, &timer_manage.ovalue, &timer_manage.value);
  45.     if(ret < 0)
  46.     {
  47.         return (-1);
  48.     }
  49.     memset(&timer_manage, 0, sizeof(struct _timer_manage));
  50.     
  51.     return(0);
  52. }


  55. /* success, return timer handle(>=0); failed, return -1 */
  56. timer_handle_t set_a_timer(int interval, int (* timer_proc) (void *arg, int arg_len), void *arg, int arg_len)
  57. {
  58.     int i;
  59.     
  60.     if(timer_proc == NULL || interval <= 0)
  61.     {
  62.         return (-1);
  63.     }
  64.     
  65.     for(i = 0; i < MAX_TIMER_CNT; i++)
  66.     {
  67.         if(timer_manage.timer_info[i].state == 1)
  68.         {
  69.             continue;
  70.         }
  71.         
  72.         memset(&timer_manage.timer_info[i], 0, sizeof(timer_manage.timer_info[i]));
  73.         timer_manage.timer_info[i].timer_proc = timer_proc;
  74.         if(arg != NULL)
  75.         {
  76.             if(arg_len > MAX_FUNC_ARG_LEN)
  77.             {
  78.                 return (-1);
  79.             }
  80.             memcpy(timer_manage.timer_info[i].func_arg, arg, arg_len);
  81.             timer_manage.timer_info[i].arg_len = arg_len;
  82.         }
  83.         timer_manage.timer_info[i].interval = interval;
  84.         timer_manage.timer_info[i].elapse = 0;
  85.         timer_manage.timer_info[i].state = 1;
  86.         break;
  87.     }
  88.     
  89.     if(i >= MAX_TIMER_CNT)
  90.     {
  91.         return (-1);
  92.     }
  93.     return (i);
  94. }


  97. /* success, return 0; failed, return -1 */
  98. int del_a_timer(timer_handle_t handle)
  99. {
  100.     if(handle < 0 || handle >= MAX_TIMER_CNT)
  101.     {
  102.         return (-1);
  103.     }
  104.     
  105.     memset(&timer_manage.timer_info[handle], 0, sizeof(timer_manage.timer_info[handle]));
  106.     
  107.     return (0);
  108. }


  111. static void sig_func(int signo)
  112. {
  113.     int i;
  114.     for(i = 0; i < MAX_TIMER_CNT; i++)
  115.     {
  116.         if(timer_manage.timer_info[i].state == 0)
  117.         {
  118.             continue;
  119.         }
  120.         timer_manage.timer_info[i].elapse++;
  121.         if(timer_manage.timer_info[i].elapse == timer_manage.timer_info[i].interval)
  122.         {
  123.             timer_manage.timer_info[i].elapse = 0;
  124.             timer_manage.timer_info[i].timer_proc(timer_manage.timer_info[i].func_arg, timer_manage.timer_info[i].arg_len);
  125.         }
  126.     }
  127. }


  130. #define _MUL_TIMER_MAIN


  133. #ifdef _MUL_TIMER_MAIN

  135. static void get_format_time(char *tstr)
  136. {
  137.     time_t t;
  138.     
  139.     t = time(NULL);
  140.     strcpy(tstr, ctime(&t));
  141.     tstr[strlen(tstr)-1] = '/0';
  142.     
  143.     return;
  144. }


  147. timer_handle_t hdl[3], call_cnt = 0;
  148. int timer_proc1(void *arg, int len)
  149. {
  150.     char tstr[200];
  151.     static int i, ret;
  152.     
  153.     get_format_time(tstr);
  154.     printf("hello %s: timer_proc1 is here./n", tstr);
  155.     if(i >= 5)
  156.     {
  157.         get_format_time(tstr);
  158.         ret = del_a_timer(hdl[0]);
  159.         printf("timer_proc1: %s del_a_timer::ret=%d/n", tstr, ret);
  160.     }
  161.     i++;
  162.     call_cnt++;
  163.     
  164.     
  165.     return (1);
  166. }

  168. int timer_proc2(void * arg, int len)
  169. {
  170.     char tstr[200];
  171.     static int i, ret;
  172.     
  173.     get_format_time(tstr);
  174.     printf("hello %s: timer_proc2 is here./n", tstr);
  175.     if(i >= 5)
  176.     {
  177.         get_format_time(tstr);
  178.         ret = del_a_timer(hdl[2]);
  179.         printf("timer_proc2: %s del_a_timer::ret=%d/n", tstr, ret);
  180.     }
  181.     i++;
  182.     call_cnt++;
  183.     
  184.     return (1);
  185. }


  188. int main(void)
  189. {
  190.     char arg[50];
  191.     char tstr[200];
  192.     int ret;
  193.     
  194.     init_mul_timer();
  195.     hdl[0] = set_a_timer(2, timer_proc1, NULL, 0);
  196.     printf("hdl[0]=%d/n", hdl[0]);
  197.     hdl[1] = set_a_timer(3, timer_proc2, arg, 50);
  198.     printf("hdl[1]=%d/n", hdl[1]);
  199.     hdl[2] = set_a_timer(3, timer_proc2, arg, 101);
  200.     printf("hdl[1]=%d/n", hdl[2]);
  201.     while(1)
  202.     {
  203.         if(call_cnt >= 12)
  204.         {
  205.             get_format_time(tstr);
  206.             ret = destroy_mul_timer();
  207.             printf("main: %s destroy_mul_timer, ret=%d/n", tstr, ret);
  208.             call_cnt++;
  209.         }
  210.         if(call_cnt >= 20)
  211.         {
  212.             break;
  213.         }
  214.     }
  215.     
  216.     return 0;
  217. }

  219. #endif

3、缺陷
   i)新建定时器、遍历定时器和删除定时器（查找哪个定时器超时）时时间复杂度都为O(n)（n是定时器的个数）;
   ii)适用环境是单线程环境，如要用于多线程，需添加同步操作。
   iii)程序中有些小bug，如对新建超时时间为0的定时器没有妥善的处理。

三、多定时器的改进版
1、思路
   改进定时器的实现，即是改善二种所指出的几个缺陷，如下是一个改进版,主要是将遍历超时时间的时间复杂度降为了O(1).
   改善思路:各定时器以一个链表的形式组织起来,除链表头定时器的超时时间是用绝对时间纪录的外,其它定时器的超时时间均用相对时间(即超时时间-前一个定时器的超时时间)纪录.
   注意,各定时器都是一次性的,当定时器的超时被处理后,定时器将被自动删除.另外如果将定时器的结点改为双向结构,可以将删除定时器的时间复杂度降为O(1).
2、数据结构
   每个定时器都有一个唯一的ID,这个ID是如下的结构体:


  1. typedef struct _timer_handle
  2. {
  3.         unsigned long ptr;
  4.         unsigned long entry_id;
  5. }*timer_handle_t;

  ptr纪录的是定时器结点的地址,entry_id则是一个自多定时器初始化后自增的id.ptr和entry_id一起组成定时器结点的key,一方面使得新建定时器时生成key的过程大为简化,另一方面使得删除定时器的时间复杂度降为O(1)（前提是定时器结点采用双向结构）。
   定时器结点的数据结构如下：

  1. /* timer entry */
  2. typedef struct _mul_timer_entry
  3. {
  4.     char is_use; /* 0, not; 1, yes */
  5.     struct _timer_handle handle;
  6.     unsigned int timeout;
  7.     unsigned int elapse; /* */
  8.     int (* timer_proc) (void *arg, unsigned int *arg_len); /* callback function */
  9.     void *arg;
  10.     unsigned int *arg_len;
  11.     struct _mul_timer_entry *etr_next;
  12. }mul_timer_entry_t;

其中的is_use是用来防止这样一种情况：用户在回调函数中调用kill_timer来删除定时器，这个时候kill_timer和遍历定时器中都有删除结点的操作，有可能将整个链表搞混乱。所以在调用用户的回调函数前先将is_use置1，在kill_timer中需检查is_use，只有在 is_use为0的情况下，才执行清理定时器结点的操作。
3、代码（windows版）
i)mul_timer.h

  1. /* This file provides an interface of multiple timers. it can't be used in multithreading environment.
  2.  * Author:bripengandre
  3.  * Date:2009-07-19
  4.  */

  6. #ifndef _MUL_TIMER_H_
  7. #define _MUL_TIMER_H_
  8. #include <windows.h>

  10. typedef struct _timer_handle
  11. {
  12.         unsigned long ptr;
  13.         unsigned long entry_id;
  14. }*timer_handle_t;

  16. /* timer entry */
  17. typedef struct _mul_timer_entry
  18. {
  19.     char is_use; /* 0, not; 1, yes */
  20.     struct _timer_handle handle;
  21.     unsigned int timeout;
  22.     unsigned int elapse; /* */
  23.     int (* timer_proc) (void *arg, unsigned int *arg_len); /* callback function */
  24.     void *arg;
  25.     unsigned int *arg_len;
  26.     struct _mul_timer_entry *etr_next;
  27. }mul_timer_entry_t;

  29. typedef struct _mul_timer_manage
  30. {
  31.     unsigned long entry_id;
  32.     unsigned int timer_cnt;
  33.     unsigned int time_unit;
  34.     struct _mul_timer_entry *etr_head;
  35.     UINT timer_id;
  36. };



  40. struct _mul_timer_manage *init_mul_timer(unsigned int time_unit);
  41. timer_handle_t set_timer(struct _mul_timer_manage *ptimer, unsigned int time_out, int (* timer_proc) (void *arg, unsigned int *arg_len), void *arg, unsigned int *arg_len);
  42. int kill_timer(struct _mul_timer_manage *ptimer, timer_handle_t hdl);
  43. int get_timeout_byhdl(struct _mul_timer_manage *ptimer, timer_handle_t hdl);
  44. int get_timeout_bytimeproc(struct _mul_timer_manage *ptimer, int (* timer_proc) (void *arg, unsigned int *arg_len));
  45. int release_mul_timer(struct _mul_timer_manage *ptimer);

  47. int is_valid_time_hdl(timer_handle_t hdl);

  49. #endif /* _MUL_TIMER_H_ */

ii)mul_timer.c

  1. #include "mul_timer.h"
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <time.h>


  7. void CALLBACK traverse_mul_timer(UINT uTimerID, UINT uMsg, DWORD dwUser, DWORD dw1, DWORD dw2);
  8. static int print_mul_timer(struct _mul_timer_manage *ptimer);

  10. struct _mul_timer_manage *init_mul_timer(unsigned int time_unit)
  11. {
  12.     struct _mul_timer_manage *p;
  13.     
  14.     if( (p = malloc(sizeof(struct _mul_timer_manage))) == NULL)
  15.     {
  16.         return (NULL);
  17.     }
  18.     
  19.     p->etr_head = NULL;
  20.     p->timer_cnt = 0;
  21.     p->time_unit = time_unit;
  22.     p->entry_id = 0;
  23.     
  24.     p->timer_id = timeSetEvent(time_unit, 0, (LPTIMECALLBACK )traverse_mul_timer, (DWORD)p, TIME_PERIODIC);
  25.     
  26.     return(p);
  27. }


  30. timer_handle_t set_timer(struct _mul_timer_manage *ptimer, unsigned int time_out, int (* timer_proc) (void *arg, unsigned int *arg_len), void *arg, unsigned int *arg_len)
  31. {
  32.     struct _mul_timer_entry *p, *prev, *pnew;
  33.     
  34.     if(ptimer == NULL || time_out == 0)
  35.     {
  36.         return (NULL);
  37.     }
  38.     
  39.     
  40.     if( (pnew = malloc(sizeof(struct _mul_timer_entry))) == NULL)
  41.     {
  42.         return (NULL);
  43.     }
  44.     pnew->is_use = 0;
  45.     pnew->arg = arg;
  46.     pnew->arg_len = arg_len;
  47.     pnew->elapse = 0;
  48.     pnew->timer_proc = timer_proc;
  49.     
  50.     p = ptimer->etr_head;
  51.     prev = NULL;
  52.     while(p != NULL)
  53.     {
  54.         if(p->timeout < time_out) /* assume the latest time_proc has higher priority */
  55.         {
  56.             time_out = time_out-p->timeout;
  57.             prev = p;
  58.             p = p->etr_next;
  59.         }
  60.         else
  61.         {
  62.             p->timeout -= time_out;
  63.             break;
  64.         }
  65.     }
  66.     
  67.     pnew->timeout = time_out;
  68.     pnew->etr_next = p;
  69.     pnew->handle.ptr = (unsigned long )pnew;
  70.     pnew->handle.entry_id = ptimer->entry_id;
  71.     ptimer->entry_id++;

  73.     if(prev == NULL)
  74.     {
  75.         ptimer->etr_head = pnew;
  76.     }
  77.     else
  78.     {
  79.         prev->etr_next = pnew;
  80.     }
  81.     ptimer->timer_cnt++;
  82.     
  83.     return (&pnew->handle);
  84. }


  87. int kill_timer(struct _mul_timer_manage *ptimer, timer_handle_t hdl)
  88. {
  89.     struct _mul_timer_entry *p, *prev;
  90.     
  91.     if(ptimer == NULL)
  92.     {
  93.         return (0);
  94.     }
  95.     
  96.     
  97.     p = ptimer->etr_head;
  98.     prev = NULL;
  99.     while(p != NULL)
  100.     {
  101.         if(p->handle.ptr == hdl->ptr && p->handle.entry_id == hdl->entry_id)
  102.         {
  103.             break;
  104.         }

  106.         prev = p;
  107.         p = p->etr_next;
  108.     }
  109.     
  110.     /* no such timer or timer is in use, return 0 */
  111.     if(p == NULL || (p != NULL && p->is_use == 1))
  112.     {
  113.         return (0);
  114.     }
  115.     
  116.     /* has found the timer */
  117.     if(prev == NULL)
  118.     {
  119.         ptimer->etr_head = p->etr_next;
  120.     }
  121.     else
  122.     {
  123.         prev->etr_next = p->etr_next;
  124.     }
  125.     
  126.     /* revise timeout */
  127.     if(p->etr_next != NULL)
  128.     {
  129.         p->etr_next->timeout += p->timeout;
  130.     }
  131.     
  132.     /* delete the timer */
  133.     free(p);
  134.     p = NULL;
  135.     ptimer->timer_cnt--;
  136.     
  137.     return (1);
  138. }


  141. int get_timeout_byhdl(struct _mul_timer_manage *ptimer, timer_handle_t hdl)
  142. {
  143.     struct _mul_timer_entry *p;
  144.     unsigned int timeout;
  145.     
  146.     if(ptimer == NULL || (struct _mul_timer_entry *)(hdl) == NULL)
  147.     {
  148.         return (-1);
  149.     }
  150.     
  151.     
  152.     timeout = 0;
  153.     p = ptimer->etr_head;
  154.     while(p != NULL)
  155.     {
  156.      if(p->handle.ptr == hdl->ptr && p->handle.entry_id == hdl->entry_id)
  157.         {
  158.             break;
  159.         }

  161.         timeout += p->timeout;
  162.         p = p->etr_next;
  163.     }
  164.     
  165.     if(p == NULL)
  166.     {
  167.         return (-1);
  168.     }
  169.     else
  170.     {
  171.         return ((int)timeout+p->timeout);
  172.     }
  173.     
  174. }


  177. int get_timeout_bytimeproc(struct _mul_timer_manage *ptimer, int (* timer_proc) (void *arg, unsigned int *arg_len))
  178. {
  179.     struct _mul_timer_entry *p;
  180.     unsigned int timeout;
  181.     
  182.     if(ptimer == NULL || timer_proc == NULL)
  183.     {
  184.         return (-1);
  185.     }
  186.     
  187.     p = ptimer->etr_head;
  188.     while((p != NULL) && (p->timer_proc != timer_proc))
  189.     {
  190.         timeout += p->timeout;
  191.         p = p->etr_next;
  192.     }
  193.     
  194.     if(p == NULL)
  195.     {
  196.         return (-1);
  197.     }
  198.     else
  199.     {
  200.         return (timeout+p->timeout);
  201.     }
  202. }


  205. int release_mul_timer(struct _mul_timer_manage *ptimer)
  206. {
  207.     struct _mul_timer_entry *p, *ptmp;
  208.     
  209.     if(ptimer == NULL)
  210.     {
  211.         return (0);
  212.     }
  213.     
  214.     timeKillEvent(ptimer->timer_id);
  215.     /* delete all timers */
  216.     p = ptimer->etr_head;
  217.     while(p != NULL)
  218.     {
  219.         ptmp = p;
  220.         p = p->etr_next;
  221.         free(ptmp);
  222.     }
  223.     /* delete timer_manage */
  224.     free(ptimer);
  225.     ptimer = NULL;
  226.     
  227.     return (1);
  228. }

  230. int is_valid_time_hdl(timer_handle_t hdl)
  231. {
  232.     if(hdl == NULL)
  233.     {
  234.         return (0);
  235.     }
  236.     else
  237.     {
  238.         return (1);
  239.     }
  240. }


  243. void CALLBACK traverse_mul_timer(UINT uTimerID, UINT uMsg, DWORD dwUser, DWORD dw1, DWORD dw2)
  244. {
  245.     struct _mul_timer_manage *ptimer;
  246.     struct _mul_timer_entry *p, *ptmp;
  247.     unsigned int timeout;
  248.     
  249.     ptimer = (struct _mul_timer_manage *)dwUser;
  250.     if(ptimer == NULL)
  251.     {
  252.         return;
  253.     }
  254.     
  255.     timeout = ptimer->time_unit;
  256.     p = ptimer->etr_head;
  257.     while(p != NULL)
  258.     {
  259.         if(p->timeout <= timeout)
  260.         {
  261.             p->is_use = 1;
  262.             p->timer_proc(p->arg, p->arg_len);
  263.             ptmp = p;
  264.             timeout -= p->timeout;
  265.             p = p->etr_next;
  266.             free(ptmp);
  267.             ptimer->etr_head = p;
  268.         }
  269.         else
  270.         {
  271.             p->timeout -= timeout;
  272.             p->elapse += timeout;
  273.             ptimer->etr_head = p;
  274.             break;
  275.         }
  276.     }
  277.     if(p == NULL)
  278.     {
  279.         ptimer->etr_head = NULL;
  280.     }
  281.     
  282.     return;
  283. }


  286. static int print_mul_timer(struct _mul_timer_manage *ptimer)
  287. {
  288.     struct _mul_timer_entry *p;
  289.     int i;
  290.     
  291.     if(ptimer == NULL)
  292.     {
  293.         return (0);
  294.     }
  295.     
  296.     printf("***************************mul_timer statistics start************************/n");
  297.     printf("this mul_timer's time_unit=%u, etr_head=%p and has %d timers:/n", ptimer->time_unit, ptimer->etr_head, ptimer->timer_cnt);
  298.     
  299.     p = ptimer->etr_head;
  300.     i = 0;
  301.     while(p != NULL)
  302.     {
  303.         printf("the %d timer: timeout=%u, elapse=%u, timer_proc=%p, arg=%p, arg_len=%p, etr_next=%p/n"
  304.             , i+1, p->timeout, p->elapse, p->timer_proc, p->arg, p->arg_len, p->etr_next);
  305.         p = p->etr_next;
  306.         i++;
  307.     }
  308.     printf("***************************mul_timer statistics end************************/n");
  309.     
  310.     return (1);
  311. }


  314. #define _MUL_TIMER_MAIN

  316. #ifdef _MUL_TIMER_MAIN

  318. static void get_format_time(char *tstr)
  319. {
  320.     time_t t;
  321.     
  322.     t = time(NULL);
  323.     strcpy(tstr, ctime(&t));
  324.     tstr[strlen(tstr)-1] = '/0';
  325.     
  326.     return;
  327. }

  329. timer_handle_t hdl[100];
  330. int call_cnt = 0;
  331. struct _mul_timer_manage *ptimer;

  333. int timer_proc1(void *arg, unsigned int *len)
  334. {
  335.     char tstr[200];
  336.     static int i, ret;
  337.     
  338.     get_format_time(tstr);
  339.     printf("call_cnt=%d, hello %s: timer_proc1 is here./n", call_cnt, tstr);
  340.     i++;
  341.     call_cnt++;
  342.     
  343.     
  344.     return (1);
  345. }

  347. int timer_proc2(void * arg, unsigned int *len)
  348. {
  349.     char tstr[200];
  350.     static int i, ret;
  351.     
  352.     get_format_time(tstr);
  353.     printf("call_cnt=%d, hello %s: timer_proc2 is here: arg = %s, len = %d./n", call_cnt, tstr, arg, *len);
  354.     i++;
  355.     call_cnt++;
  356.     
  357.     return (1);
  358. }


  361. int main(void)
  362. {
  363.     char arg[50] = "hello, multiple timers";
  364.     char tstr[200];
  365.     int ret;
  366.     int len = 50, i;
  367.     
  368.     ptimer = init_mul_timer(1000);
  369.     
  370.     for(i = 0; i < 10; i++)
  371.     {
  372.         hdl[i<<1] = set_timer(ptimer, 1000*(i+1), timer_proc1, NULL, NULL);
  373.         printf("hdl[0i<<1=%d, is_valid_hdl=%d/n", hdl[i<<1], is_valid_time_hdl(hdl[i<<1]));
  374.         hdl[(i<<1)+1] = set_timer(ptimer, 3000*(i+1), timer_proc2, arg, &len);
  375.         printf("hdl[i<<1+1]=%d, is_valid_hdl=%d/n", hdl[(i<<1)+1], is_valid_time_hdl(hdl[(i<<1)+1]));
  376.         print_mul_timer(ptimer);
  377.     }

  379.     ret = kill_timer(ptimer, hdl[17]);
  380.     printf("ret=kill_timer=%d/n", ret);
  381.     print_mul_timer(ptimer);
  382.     printf("hd[19]->timout=%d/n", get_timeout_byhdl(ptimer, hdl[19]));

  384.     while(1)
  385.     {
  386.         if(call_cnt == 15)
  387.         {
  388.             get_format_time(tstr);
  389.             ret = release_mul_timer(ptimer);
  390.             printf("call_cnt=%d, main: %s destroy_mul_timer, ret=%d/n", call_cnt, tstr, ret);
  391.             call_cnt++;
  392.         }
  393.     }
  394.     
  395.     return 0;
  396. }

  398. #endif

3、缺陷
i)新建定时器的时间复杂度为O(n),删除定时器的时间复杂度也为O(n)(简单地将定时器结点改为双向结构,可将复杂度降为O(1));
ii)不能用于多线程环境
四 、多定时器的工业级实现
 1、time wheelz算法
   以前的BSD内核以及现在的linux内核的实现与三中所用算法相似（未实证，只是据说），据说现在的BSD内核已采用了较好的time wheelz算法。
   time wheez算法的优点：
   i)将新建定时器的时间复杂度降近似为O(1)。它根据定时器的超时值，将新定时器散列到hash桶中；
   ii)遍历检查定时器的时间复杂度也近似为O(桶大小)，如果散列均匀。
   iii)删除定时器的时间复杂度近似为O(1)，通过hash算法或临时存储（空间换时间的算法）。
2、time wheelz的实现
   请参考文末给出的两个论文，惭愧得很，文章我也只是稍微瞄了下，以后有用得着的时候再深究吧。
五、参考文章
1、 Adam M. Costello and George Varghess, "Redesigning the BSD Callout and Timer Facilities". 1995.01,这篇文章实现了用time wheelz算法改善BSD内核的定时器算法，google一下，有免费下载；
2、George Varghess, Anthony Lauch, "Hashed and Hierarchical Timing Wheels: Efficient Data Structures for Implementing a Timer Facility". IEEE: 1997.12，这个看作者有没有提供免费下载了，否则是要从IEEE那里获取了~~
阅读(1634) | 评论(0) | 转发(0) |
0

上一篇：一个软件实现的Linux看门狗—soft_wdt

下一篇：udp发送端口号必须要了解的事

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6