分享自己最新改写的超时检查代码evtimer

redor

后续的改进会更新在　https://sbase.googlecode.com/svn/trunk/devel/libsbase/
使用例子在evtimer.c　main函数里,　在多线程使用中就只需要在主线程里或者独立的线程里作evtimer_check()就好了,　
超时的事件通过evtimer_add()添加的handler和arg返回,　
evtimer_add()注册的时候会返回一个evtimer_id 记住这个id 可以通过这个id更新timeout时间和删除超时检查.
最后evtimer_clean()　清理一下就ＯＫ,　Ｃ++使用自行加Ｃ++兼容那个头就好了;
windows下使用在 把xmm_new()　改成　calloc() xmm_free() 改成free()
另外换掉那个mutex_lock()　mutex_unlock()　就可以了.　我没写过windows的代码.
有bug的话请提交给我邮箱.sounos@gmail.com

1. 
   
2. #ifndef _EVTIMER_H
   
3. #define _EVTIMER_H
   
4. typedef void (EVTCALLBACK)(void *);
   
5. typedef struct _EVTNODE
   
6. {
   
7.     int id;
   
8.     int ison;
   
9.     off_t evusec;
   
10.     void *arg;
    
11.     EVTCALLBACK *handler;
    
12.     struct _EVTNODE *prev;
    
13.     struct _EVTNODE *next;
    
14. }EVTNODE;
    
15. #define  EVTNODE_LINE_NUM   1024
    
16. #define  EVTNODE_LINE_MAX   102400
    
17. typedef struct _EVTIMER
    
18. {
    
19.    int nevlist;
    
20.    int ntimeout;
    
21.    EVTNODE *evlist[EVTNODE_LINE_MAX];
    
22.    EVTNODE *timeouts[EVTNODE_LINE_MAX];
    
23.    EVTNODE *left;
    
24.    EVTNODE *head;
    
25.    EVTNODE *tail;
    
26.    void *mutex;
    
27. }EVTIMER;
    
28. 
    
29. /* initialize evtimer */
    
30. EVTIMER *evtimer_init();
    
31. /* add event timer */
    
32. int evtimer_add(EVTIMER *evtimer, off_t timeout, EVTCALLBACK *handler, void *arg);
    
33. /* update event timer */
    
34. int evtimer_update(EVTIMER *evtimer, int evid, off_t timeout, EVTCALLBACK *handler, void *arg);
    
35. /* delete event timer */
    
36. int evtimer_delete(EVTIMER *evtimer, int evid);
    
37. /* check timeout */
    
38. void evtimer_check(EVTIMER *evtimer);
    
39. /* reset evtimer */
    
40. void evtimer_reset(EVTIMER *evtimer);
    
41. /* clean evtimer */
    
42. void evtimer_clean(EVTIMER *evtimer);
    
43. #define PEVTIMER(ptr) ((EVTIMER *)ptr)
    
44. #define EVTIMER_INIT() evtimer_init()
    
45. #define EVTIMER_ADD(ptr, timeout, evhandler, evarg) \
    
46.     evtimer_add(PEVTIMER(ptr), (off_t)timeout, evhandler, evarg)
    
47. #define EVTIMER_UPDATE(ptr, evid, timeout, evhandler, evarg) \
    
48.     evtimer_update(PEVTIMER(ptr), evid, (off_t)timeout, evhandler, evarg)
    
49. #define EVTIMER_DEL(ptr, evid) evtimer_delete(PEVTIMER(ptr), evid)
    
50. #define EVTIMER_CHECK(ptr) evtimer_check(PEVTIMER(ptr))
    
51. #define EVTIMER_RESET(ptr) evtimer_reset(PEVTIMER(ptr))
    
52. #define EVTIMER_CLEAN(ptr) evtimer_clean(PEVTIMER(ptr))
    
53. #endif
    

复制代码

evtimer.c

1. 
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <unistd.h>
   
5. #include <string.h>
   
6. #include <sys/time.h>
   
7. #include "xmm.h"
   
8. #include "evtimer.h"
   
9. #include "mutex.h"
   
10. /* evtimer push */
    
11. void evtimer_push(EVTIMER *evtimer, EVTNODE *node)
    
12. {
    
13.     EVTNODE *tmp = NULL;
    
14.     int evid = 0;
    
15. 
    
16.     if(evtimer && node)
    
17.     {
    
18.         evid = node->id;
    
19.         node->next = node->prev = NULL;
    
20.         if(evtimer->tail  == NULL || evtimer->head == NULL)
    
21.             evtimer->head = evtimer->tail = node;
    
22.         else
    
23.         {
    
24.             if(node->evusec >= evtimer->tail->evusec)
    
25.             {
    
26.                 node->prev = evtimer->tail;
    
27.                 evtimer->tail->next = node;
    
28.                 evtimer->tail = node;
    
29.             }
    
30.             else if(node->evusec < evtimer->head->evusec)
    
31.             {
    
32.                 node->next = evtimer->head;
    
33.                 evtimer->head->prev = node;
    
34.                 evtimer->head = node;
    
35.             }
    
36.             else
    
37.             {
    
38.                 tmp = evtimer->tail->prev;
    
39.                 while(tmp && tmp->evusec > node->evusec)
    
40.                     tmp = tmp->prev;
    
41.                 if(tmp)
    
42.                 {
    
43.                     node->next = tmp->next;
    
44.                     node->prev = tmp;
    
45.                     tmp->next = node;
    
46.                     node->next->prev = node;
    
47.                 }
    
48.             }
    
49.         }
    
50.     }
    
51.     return ;
    
52. }
    
53. 
    
54. /* add event timer */
    
55. int evtimer_add(EVTIMER *evtimer, off_t timeout, EVTCALLBACK *handler, void *arg)
    
56. {
    
57.     int evid = -1, x = 0, i = 0;
    
58.     struct timeval tv = {0};
    
59.     EVTNODE *node = NULL;
    
60. 
    
61.     if(evtimer && handler && timeout > 0)
    
62.     {
    
63.         MUTEX_LOCK(evtimer->mutex);
    
64.         if((node = evtimer->left))
    
65.         {
    
66.             evtimer->left = node->next;
    
67.         }
    
68.         else
    
69.         {
    
70.             if((x = evtimer->nevlist) < EVTNODE_LINE_MAX
    
71.                     && (node = (EVTNODE *)xmm_new(sizeof(EVTNODE) * EVTNODE_LINE_NUM)))
    
72.             {
    
73.                 evtimer->evlist[x] = node;
    
74.                 evtimer->nevlist++;
    
75.                 //fprintf(stdout, "%s::%d lines:%d\n", __FILE__, __LINE__, evtimer->nevlist);
    
76.                 x *= EVTNODE_LINE_NUM;
    
77.                 node[0].id = x;
    
78.                 i = 1;
    
79.                 while(i < EVTNODE_LINE_NUM)
    
80.                 {
    
81.                     node[i].id = i + x;
    
82.                     node[i].next = evtimer->left;
    
83.                     evtimer->left = &(node[i]);
    
84.                     ++i;
    
85.                 }
    
86.             }
    
87.         }
    
88.         if(node)
    
89.         {
    
90.             evid = node->id;
    
91.             node->handler = handler;
    
92.             node->arg = arg;
    
93.             node->ison = 1;
    
94.             gettimeofday(&tv, NULL);
    
95.             node->evusec = (off_t)(tv.tv_sec * 1000000ll + tv.tv_usec * 1ll) + timeout;
    
96.             evtimer_push(evtimer, node);
    
97.         }
    
98.         MUTEX_UNLOCK(evtimer->mutex);
    
99.     }
    
100.     return evid;
     
101. }
     
102. 
     
103. /* update event timer */
     
104. int evtimer_update(EVTIMER *evtimer, int evid, off_t timeout, EVTCALLBACK *handler, void *arg)
     
105. {
     
106.     EVTNODE *nodes = NULL, *node = NULL;
     
107.     int x = 0, i = 0, ret = -1;
     
108.     struct timeval tv = {0};
     
109. 
     
110.     if(evtimer && evid >= 0 && evid < ((evtimer->nevlist+1) * EVTNODE_LINE_NUM))
     
111.     {
     
112.         MUTEX_LOCK(evtimer->mutex);
     
113.         x = evid / EVTNODE_LINE_NUM;
     
114.         i = evid % EVTNODE_LINE_NUM;
     
115.         if((nodes = evtimer->evlist[x]) && (node = &(nodes[i])) && node->ison)
     
116.         {
     
117.             if(node->prev) node->prev->next = node->next;
     
118.             if(node->next) node->next->prev = node->prev;
     
119.             if(node == evtimer->head) evtimer->head = node->next;
     
120.             if(node == evtimer->tail) evtimer->tail = node->prev;
     
121.             node->handler = handler;
     
122.             node->arg = arg;
     
123.             gettimeofday(&tv, NULL);
     
124.             node->evusec = (off_t)(tv.tv_sec * 1000000ll + tv.tv_usec * 1ll) + timeout;
     
125.             evtimer_push(evtimer, node);
     
126.             ret = 0;
     
127.         }
     
128.         MUTEX_UNLOCK(evtimer->mutex);
     
129.     }
     
130.     return ret;
     
131. }
     
132. 
     
133. /* delete event timer */
     
134. int evtimer_delete(EVTIMER *evtimer, int evid)
     
135. {
     
136.     EVTNODE *nodes = NULL, *node = NULL;
     
137.     int ret = -1, i = 0, x = 0;
     
138. 
     
139.     if(evtimer && evid >= 0 && evid < ((evtimer->nevlist+1) * EVTNODE_LINE_NUM))
     
140.     {
     
141.         MUTEX_LOCK(evtimer->mutex);
     
142.         x = evid / EVTNODE_LINE_NUM;
     
143.         i = evid % EVTNODE_LINE_NUM;
     
144.         if((nodes = evtimer->evlist[x]) && (node = &(nodes[i])) && node->ison)
     
145.         {
     
146.             //fprintf(stdout, "%s::%d delete evid:%d\n", __FILE__, __LINE__, evid);
     
147.             if(node->prev) node->prev->next = node->next;
     
148.             if(node->next) node->next->prev = node->prev;
     
149.             if(node == evtimer->head) evtimer->head = node->next;
     
150.             if(node == evtimer->tail) evtimer->tail = node->prev;
     
151.             memset(node, 0, sizeof(EVTNODE));
     
152.             node->id = evid;
     
153.             node->next = evtimer->left;
     
154.             evtimer->left = node;
     
155.         }
     
156.         MUTEX_UNLOCK(evtimer->mutex);
     
157.     }
     
158.     return ret;
     
159. }
     
160. 
     
161. /* check timeout */
     
162. void evtimer_check(EVTIMER *evtimer)
     
163. {
     
164.     EVTCALLBACK *handler = NULL;
     
165.     struct timeval tv = {0};
     
166.     EVTNODE *node = NULL;
     
167.     off_t now = 0;
     
168.     int i = 0;
     
169. 
     
170.     if(evtimer && evtimer->head)
     
171.     {
     
172.         MUTEX_LOCK(evtimer->mutex);
     
173.         gettimeofday(&tv, NULL);
     
174.         now = (off_t)(tv.tv_sec * 1000000ll + tv.tv_usec * 1ll);
     
175.         evtimer->ntimeout = 0;
     
176.         while(evtimer->ntimeout < EVTNODE_LINE_MAX
     
177.                 && (node = evtimer->head) && node->evusec < now)
     
178.         {
     
179.             //if(node->handler) node->handler(node->arg);
     
180.             if((evtimer->head = node->next))
     
181.                 evtimer->head->prev = NULL;
     
182.             else
     
183.                 evtimer->tail = NULL;
     
184.             evtimer->timeouts[evtimer->ntimeout++] = node;
     
185.             node->next = node->prev = NULL;
     
186.         }
     
187.         MUTEX_UNLOCK(evtimer->mutex);
     
188.         for(i = 0; i < evtimer->ntimeout; i++)
     
189.         {
     
190.             if((node = evtimer->timeouts[i]) && node->next == NULL && node->prev == NULL
     
191.                     && node->ison && (handler = node->handler))
     
192.                 handler(node->arg);
     
193.         }
     
194.     }
     
195.     return ;
     
196. }
     
197. 
     
198. /* reset evtimer */
     
199. void evtimer_reset(EVTIMER *evtimer)
     
200. {
     
201.     EVTNODE *tmp = NULL, *node = NULL;
     
202.     int id = -1;
     
203. 
     
204.     if(evtimer && (node = evtimer->head))
     
205.     {
     
206.         do
     
207.         {
     
208.             id = node->id;
     
209.             tmp = node;
     
210.             node = node->next;
     
211.             memset(tmp, 0, sizeof(EVTNODE));
     
212.             tmp->id = id;
     
213.             tmp->next = evtimer->left;
     
214.             evtimer->left = tmp;
     
215.         }while(node);
     
216.     }
     
217.     return ;
     
218. }
     
219. 
     
220. /* clean evtimer */
     
221. void evtimer_clean(EVTIMER *evtimer)
     
222. {
     
223.     int i = 0;
     
224. 
     
225.     if(evtimer)
     
226.     {
     
227.         MUTEX_DESTROY(evtimer->mutex);
     
228.         for(i = 0; i < evtimer->nevlist; i++)
     
229.         {
     
230.             xmm_free(evtimer->evlist[i], sizeof(EVTNODE) * EVTNODE_LINE_NUM);
     
231.         }
     
232.         xmm_free(evtimer, sizeof(EVTIMER));
     
233.     }
     
234. 
     
235.     return ;
     
236. }
     
237. 
     
238. /* intialize evtimer */
     
239. EVTIMER *evtimer_init()
     
240. {
     
241.     EVTIMER *evtimer = NULL;
     
242. 
     
243.     if((evtimer = (EVTIMER *)xmm_new(sizeof(EVTIMER))))
     
244.     {
     
245.         MUTEX_INIT(evtimer->mutex);
     
246.     }
     
247.     return evtimer;
     
248. }
     
249. 
     
250. #ifdef _DEBUG_EVTIMER
     
251. void evtimer_handler(void *arg)
     
252. {
     
253.     fprintf(stdout, "active evtimer\n");
     
254.     return ;
     
255. }
     
256. int main()
     
257. {
     
258.     EVTIMER *evtimer = NULL;
     
259.     int i = 0, id = 0, max = 1000000;
     
260.     off_t timeout = 10000000;
     
261. 
     
262.     if((evtimer = evtimer_init()))
     
263.     {
     
264.         for(i = 0; i < max; i++)
     
265.         {
     
266.             timeout = random()%1000000000;
     
267.             id = evtimer_add(evtimer, timeout, &evtimer_handler, NULL);
     
268.             fprintf(stdout, "%d:%lu\n", id, (unsigned long)(timeout));
     
269.         }
     
270.         fprintf(stdout, "starting check()");
     
271.         evtimer_check(evtimer);
     
272.         fprintf(stdout, "over check()");
     
273.         evtimer_reset(evtimer);
     
274.         fprintf(stdout, "over reset()");
     
275.         evtimer_clean(evtimer);
     
276.     }
     
277.     return 0;
     
278. }
     
279. #endif
     

复制代码

ecjtubaowp

看看。

ydfgic

有一点不明白，这代码是用来干嘛的？
仅仅是check预定的项目有没有在一段时间后要执行吗？
坦白说，意义不大
因为所有的回调操作都是在你check的时候执行的，也就是说这些任务并不是在你设定的时间执行的。

我以前写过一个类似的 timequeue ，记时执行队列，写的很简陋，内部用select做定时器，到期的任务，pop出queue，然后调整这个queue里的每个任务的时间戳，再设定select超时等待。queue里按照时间戳排序
（可以优化成分时段更新时间戳--没必要都更新，占用了cpu），这个queue就比较符合我们需要，定时执行任务。

redor

有一点不明白，这代码是用来干嘛的？
仅仅是check预定的项目有没有在一段时间后要执行吗？
坦白说，意义不 ...
ydfgic 发表于 2010-11-04 18:12

   你理解的基本不对 用来做超时检查的　不是用来作定时器的,　比如要检查一个fd是否一定时间内没有数据读写.....　相当于事件超时检查,　libevent里也有一个,不过跟它那个实现不一样.