编写用户侧定时器

墨蓝 2022-08-20 13:16 174阅读 0赞

定时器是我们在平时开发中经常使用到的工具，特别是在协议的编写上更是必不可少的组成部分。虽然系统本身给我们提供了定时器，但是有的时候，我们也想自己编写一个粗粒度的定时器，比如说在单元测试的时候。大家只要看到下面的实例代码，其实就会发现，只要利用一下sleep函数，编写属于自己的定时器原来不是一件复杂的事情。当然，在实现自己的定时器之前，你需要明白自己的定时器应该设计成什么样子？比如说，

（1）定时器是否需要做互斥处理？

（2）定时器支持那几种类型？

（3）定时器支持的最大粒度是多少？有没有什么限制？

（4）定时器的接口是什么？

（5）定时器怎么遍历、组织和运行？

下面的代码就是我自己练习时编写的一个定时器，具有下面几个特点：

（1）支持1s为基本单位的定时操作；

（2）支持定时器互斥操作，适合移植；

（3）支持单次和循环两种定时器；

（4）tick计数和定时函数处理是由不同线程完成；

（5）定时器接口简单，和linux定时器接口基本一致。

最后贴出自己的定时器代码，欢迎大家多提宝贵意见。

**\[cpp\]**  [view plain][]  [copy][view plain]

1.  **struct** TIMER  
2.  \{  
3.      **int** type;  
4.      **int** state;  
5.      **int** count;  
6.      **int** expire;  
7.      **void** (\*func)(**void**\*);  
8.      **void**\* param;  
9.      **struct** LINK\_NODE node;  
10.     **char** name\[MAX\_NAME\_LEN\];  
11. \};  
12.   
13. \#define MAX\_NAME\_LEN 16  
14. \#define TIMER\_LOCK\_INIT()  
15. \#define TIMER\_LOCK(sem)  
16. \#define TIMER\_UNLOCK(sem)  
17.   
18. \#define STATUS int  
19. \#define MAX\_TIMER\_VALUE (7\*24\*3600)  
20.   
21. **enum**  
22. \{  
23.     SINGLE\_SHOT = 1,  
24.     RECYCLE\_TYPE = 2  
25. \};  
26.   
27. **enum**  
28. \{  
29.     TIMER\_ACTIVE = 1,  
30.     TIMER\_NOT\_ACTIVE = 2  
31. \};  
32.   
33. **static** **int** g\_timer\_count;  
34. **static** **struct** LINK\_NODE g\_timer\_head;  
35. **static** **HANDLE** h\_timer\_sem;  
36.   
37. **void** timer\_init()  
38. \{  
39.     g\_timer\_count = 0;  
40.     link\_init(&g\_timer\_head);  
41.     h\_timer\_sem = TIMER\_LOCK\_INIT();  
42. \}  
43.   
44. STATUS alloc\_timer(**const** **char**\* name, **int** type, **int** count, **void** (\*func)(**void**\*), **void**\* param)  
45. \{  
46.     **struct** LINK\_NODE\* p\_node;  
47.     **struct** TIMER\* p\_timer;  
48.   
49.     **if**(NULL == name || NULL == func || NULL == param)  
50.     \{  
51.         **return** FALSE;  
52.     \}  
53.   
54.     **if**(strlen(name) >= MAX\_NAME\_LEN)  
55.     \{  
56.         **return** FALSE;  
57.     \}  
58.   
59.     **if**(SINGLE\_SHOT != type && RECYCLE\_TYPE != type)  
60.     \{  
61.         **return** FALSE;  
62.     \}  
63.   
64.     **if**(MAX\_TIMER\_VALUE < count || 0 == count)  
65.     \{  
66.         **return** FALSE;  
67.     \}  
68.       
69.     TIMER\_LOCK(h\_timer\_sem);  
70.     **for**(p\_node = g\_timer\_head.next; NULL != p\_node; p\_node = p\_node->next)  
71.     \{  
72.         p\_timer = GET\_DATA\_BY\_ADDRESS(p\_node, **struct** TIMER, node);  
73.         **if**(0 == strncmp(p\_timer->name, name, strlen(name)))  
74.         \{  
75.             TIMER\_UNLOCK(h\_timer\_sem);  
76.             **return** FALSE;  
77.         \}  
78.     \}  
79.       
80.     p\_timer = (**struct** TIMER\*)malloc(**sizeof**(**struct** TIMER));  
81.     **if**(NULL == p\_timer)  
82.     \{  
83.         TIMER\_UNLOCK(h\_timer\_sem);  
84.         **return** FALSE;  
85.     \}  
86.   
87.     memset(p\_timer, 0, **sizeof**(**struct** TIMER));  
88.     strncpy(p\_timer->name, name, strlen(name));  
89.     p\_timer->type = type;  
90.     p\_timer->count = count;  
91.     p\_timer->func = func;  
92.     p\_timer->param = param;  
93.     p\_timer->state = TIMER\_NOT\_ACTIVE;  
94.   
95.     add\_node\_into\_link(&p\_timer->node, &g\_timer\_head);  
96.     TIMER\_UNLOCK(h\_timer\_sem);  
97.       
98.     **return** TRUE;  
99. \}  
100.   
101.   
102. STATUS timer\_start(**const** **char**\* name)  
103. \{  
104.     **struct** LINK\_NODE\* p\_node;  
105.     **struct** TIMER\* p\_timer;  
106.   
107.     **if**(NULL == name || strlen(name) >= MAX\_NAME\_LEN)  
108.     \{  
109.         **return** FALSE;  
110.     \}  
111.   
112.     TIMER\_LOCK(h\_timer\_sem);  
113.     **for**(p\_node = g\_timer\_head.next; NULL != p\_node; p\_node = p\_node->next)  
114.     \{  
115.         p\_timer = GET\_DATA\_BY\_ADDRESS(p\_node, **struct** TIMER, node);  
116.         **if**(0 == strncmp(p\_timer->name, name, strlen(name)))  
117.         \{  
118.             **break**;  
119.         \}  
120.     \}  
121.   
122.     **if**(NULL == p\_node)  
123.     \{  
124.         TIMER\_UNLOCK(h\_timer\_sem);  
125.         **return** FALSE;  
126.     \}  
127.   
128.     **if**(TIMER\_NOT\_ACTIVE == p\_timer->state)  
129.     \{  
130.         p\_timer->expire = g\_timer\_count + p\_timer->count;  
131.         p\_timer->state = TIMER\_ACTIVE;  
132.     \}  
133.   
134.     TIMER\_UNLOCK(h\_timer\_sem);  
135.     **return** TRUE;  
136. \}  
137.   
138.   
139. STATUS timer\_del(**const** **char**\* name)  
140. \{     
141.     **struct** LINK\_NODE\* p\_node;  
142.     **struct** TIMER\* p\_timer;  
143.   
144.     **if**(NULL == name || strlen(name) >= MAX\_NAME\_LEN)  
145.     \{  
146.         **return** FALSE;  
147.     \}  
148.   
149.     TIMER\_LOCK(h\_timer\_sem);  
150.     **for**(p\_node = g\_timer\_head.next; NULL != p\_node; p\_node = p\_node->next)  
151.     \{  
152.         p\_timer = GET\_DATA\_BY\_ADDRESS(p\_node, **struct** TIMER, node);  
153.         **if**(0 == strncmp(p\_timer->name, name, strlen(name)))  
154.         \{  
155.             **break**;  
156.         \}  
157.     \}  
158.   
159.     **if**(NULL == p\_node)  
160.     \{  
161.         TIMER\_UNLOCK(h\_timer\_sem);  
162.         **return** FALSE;  
163.     \}  
164.   
165.     delete\_node\_from\_link(&p\_timer->node);  
166.     TIMER\_UNLOCK(h\_timer\_sem);  
167.     free(p\_timer);  
168.     **return** TRUE;  
169. \}  
170.   
171.   
172. **void** timer\_run()  
173. \{  
174.     **struct** LINK\_NODE\* p\_node;  
175.     **struct** TIMER\* p\_timer;  
176.     **int** count;  
177.   
178.     **while**(1)  
179.     \{  
180.         count = g\_timer\_count;  
181.         TIMER\_LOCK(h\_timer\_sem);  
182.         **for**(p\_node = g\_timer\_head.next; NULL != p\_node; p\_node = p\_node->next)  
183.         \{  
184.             p\_timer = GET\_DATA\_BY\_ADDRESS(p\_node, **struct** TIMER, node);  
185.             **if**(TIMER\_ACTIVE == p\_timer->state && count > p\_timer->expire)  
186.             \{  
187.                 p\_timer->func(p\_timer->param);  
188.   
189.                 **if**(SINGLE\_SHOT == p\_timer->type)  
190.                 \{  
191.                     p\_timer->state = TIMER\_NOT\_ACTIVE;  
192.                 \}  
193.                 **else**  
194.                 \{  
195.                     p\_timer->expire = count + p\_timer->count;  
196.                 \}  
197.             \}  
198.         \}  
199.   
200.         TIMER\_UNLOCK(h\_timer\_sem);  
201.         sleep(1);  
202.     \}  
203. \}  
204.   
205.   
206. **void** tick\_process()  
207. \{  
208.     **while**(1)  
209.     \{  
210.         g\_timer\_count ++;  
211.         sleep(1);  
212.     \}  
213. \}

[view plain]: http://blog.csdn.net/feixiaoxing/article/details/7849552#