libevent介绍及示例

一、Libevent简介

    libevent是一个基于事件触发的网络库，适用于windows、linux、bsd等多种平台，内部使用select、epoll、kqueue等系统调用管理事件机制。官网：http://libevent.org/

特点：

• 事件驱动，高性能;
• 轻量级，专注于网络，不如ACE那么臃肿庞大，只提供了简单的网络API的封装，线程池，内存池，递归锁等均需要自己实现；
• 开放源码，代码相当精炼、易读；
• 跨平台，支持Windows、Linux、BSD和Mac OS；
• 支持多种I/O多路复用技术（epoll、poll、dev/poll、select和kqueue等），在不同的操作系统下，做了多路复用模型的抽象，可以选择使用不同的模型，通过事件函数提供服务；
• 支持I/O，定时器和信号等事件；
• 采用Reactor模式；

二、源码组织结构

    Libevent 的源代码虽然都在一层文件夹下面，但是其代码分类还是相当清晰的，主要可分为头文件、内部使用的头文件、辅助功能函数、日志、libevent框架、对系 统I/O多路复用机制的封装、信号管理、定时事件管理、缓冲区管理、基本数据结构和基于libevent的两个实用库等几个部分，有些部分可能就是一个源文件。

1）头文件

主要就是event.h：事件宏定义、接口函数声明，主要结构体event的声明；

2）内部头文件

xxx-internal.h：内部数据结构和函数，对外不可见，以达到信息隐藏的目的；

3）libevent框架

event.c：event整体框架的代码实现；

4）对系统I/O多路复用机制的封装

epoll.c：对epoll的封装；

select.c：对select的封装；

devpoll.c：对dev/poll的封装;

kqueue.c：对kqueue的封装；

5）定时事件管理

min-heap.h：其实就是一个以时间作为key的小根堆结构；

6）信号管理

signal.c：对信号事件的处理；

7）辅助功能函数

evutil.h 和evutil.c：一些辅助功能函数，包括创建socket pair和一些时间操作函数：加、减和比较等。

8）日志

log.h和log.c：log日志函数

9）缓冲区管理

evbuffer.c和buffer.c：libevent对缓冲区的封装；

10）基本数据结构

compat/sys下的两个源文件：queue.h是libevent基本数据结构的实现，包括链表，双向链表，队列等；_libevent_time.h：一些用于时间操作的结构体定义、函数和宏定义；

11）实用网络库

http和evdns：是基于libevent实现的http服务器和异步dns查询库；

三、示例

1、获取版本

1. // gcc getVersion.c -o getVersion -levent
2.  
3. <event.h>
4. <stdio.h>
5.  
6. int main()
7. {
8. const char *version = event_get_version();
9. ("%s\n",version);
10. ;
11. }

2、timer程序

1. // gcc timer.c -o timer -levent
2. <stdio.h>
3. <stdlib.h>
4. <string.h>
5. <time.h>
6. <event2/event.h>
7. <event2/event_struct.h>
8.  
9.  #define N 300
10.  #define BUFLEN 256
11.  
12. ;
13.  struct ST_EventWithDescription
14. {
15. *p_event;
16. int time_interval;
17. [BUFLEN];
18. };
19.  
20. (evutil_socket_t fd, short event, void *arg)
21. {
22. , difference;
23. *pSTEvent = arg;
24. *timeout = pSTEvent->p_event;
25. ;
26.  
27. (&newtime, NULL);
28. (&newtime, &lasttime, &difference);
29. = difference.tv_sec + (difference.tv_usec / 1.0e6);
30.  
31. ("%s called at %d: %.3f seconds since my last work.\n",
32. (char*)pSTEvent->lable,(int)newtime.tv_sec, elapsed);
33. = newtime;
34.  
35. ;
36. (&tv);
37. .tv_sec = pSTEvent->time_interval;
38. (timeout, &tv);
39. }
40.  
41. (struct ST_EventWithDescription *stEventDescription,
42. *m_event,int time_interval,char* m_lable)
43. {
44. ->p_event = m_event;
45. ->time_interval = time_interval;
46. (stEventDescription->lable,0,sizeof(stEventDescription->lable));
47. (stEventDescription->lable,m_lable,strlen(m_lable)+1);
48. }
49.  
50. (int *arr,int n)
51. {
52. int i;
53. (time(NULL));
54. for(i=0; i<n; ++i)
55. {
56. *(arr+i) = rand()%n + 1;
57. //*(arr+i) = i+1;
58. }
59. }
60.  
61. int main(int argc, char **argv)
62. {
63. [N];
64. [N];
65. int time_interval[N];
66. int i=0;
67.  
68. ;
69. *base;
70. int flags = 0;
71.  
72. (time_interval,N);
73.  
74. = event_base_new();
75. (&tv);
76.  
77. for(i=0; i<N; ++i)
78. {
79. [BUFLEN]= {0};
80. (buf,"task%d",i+1);
81. (stEvent+i,timeout+i,time_interval[i],buf);
82. (timeout+i, base, -1, flags, timeout_cb, (void*)(stEvent+i));
83. (timeout+i, &tv);
84. }
85.      
86. (&lasttime, NULL);
87. (base);
88.  
89. (0);
90. }

3、socket程序

1. #include <stdio.h>
2. <string.h>
3. <stdlib.h>
4. <netinet/in.h>
5. <netinet/tcp.h>
6. <event.h>
7. <sys/types.h>
8. <sys/socket.h>
9. <errno.h>
10. <fcntl.h>
11.  
12.  
13.  
14. = 8080;
15. = INADDR_ANY;//任意地址的值就是0
16. int MaxConnections = 1024;
17. int ServerSocket;
18. ;//创建event
19.  
20.  
21. //不论在什么平台编写网络程序，都应该使用NONBLOCK将一个socket设置成非阻塞模式。这样可以保证你的程序至少不会在recv/send/accept/connect这些操作上发生block从而将整个网络服务都停下来
22. int SetNonblock(int fd)
23. {
24. int flags;
25.      
26. if ((flags = fcntl(fd, F_GETFL)) == -1) { //用来操作文件描述符的一些特性
27. -1;
28. }
29.  
30. if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
31. -1;
32. }
33.  
34. ;
35. }
36.  
37. //这个函数当客户端的socket可读时由libevent调用
38. (int fd, short ev, void *arg)
39. {
40. *client = (struct client *)arg;
41. [8196];
42. int len, wlen;
43.  
44. //会把参数fd 所指的文件传送count个字节到buf指针所指的内存中
45. len = read(fd, buf, sizeof(buf));
46. if (len == 0) {
47. /* 客户端断开连接，在这里移除读事件并且释放客户数据结构 */
48. ("disconnected\n");
49. (fd);
50. (&ServerEvent);
51. (client);
52. ;
53. } else if (len < 0) {
54. /* 出现了其它的错误，在这里关闭socket，移除事件并且释放客户数据结构 */
55. ("socket fail %s\n", strerror(errno));
56. (fd);
57. (&ServerEvent);
58. (client);
59. ;
60. }
61. /* 
62.       为了简便，我们直接将数据写回到客户端。通常我们不能在非阻塞的应用程序中这么做，
63.         我们应该将数据放到队列中，等待可写事件的时候再写回客户端。 
64.       如果使用多个终端进行socket连接会出现错误socket fail Bad file descriptor
65. */
66. = write(fd, buf, len);
67. if (wlen < len) {
68. ("not all data write back to client\n");
69. }
70.  
71. ;
72. }
73.  
74. /*
75. : 
76. int fd:触发事件的文件描述符. 
77. :触发事件的类型EV_TIMEOUT,EV_SIGNAL, EV_READ, or EV_WRITE. 
78. * :由arg参数指定的变量. 
79. */
80. (int fd, short ev, void *arg)
81. {
82. int cfd;
83. ;
84. = sizeof(addr);
85. int yes = 1;
86. int retval;
87.  
88. //将从连接请求队列中获得连接信息，创建新的套接字，并返回该套接字的文件描述符。
89. //新创建的套接字用于服务器与客户机的通信，而原来的套接字仍然处于监听状态。
90. //该函数的第一个参数指定处于监听状态的流套接字
91. = accept(fd, (struct sockaddr *)&addr, &addrlen);
92. if (cfd == -1) {
93. ("accept(): can not accept client connection");
94. ;
95. }
96. if (SetNonblock(cfd) == -1) {
97. (cfd);
98. ;
99. }
100.  
101. //设置与某个套接字关联的选项
102. //参数二 IPPROTO_TCP:TCP选项
103. //参数三 TCP_NODELAY 不使用Nagle算法 选择立即发送数据而不是等待产生更多的数据然后再一次发送
104. // 更多参数TCP_NODELAY 和 TCP_CORK
105. //参数四 新选项TCP_NODELAY的值
106. if (setsockopt(cfd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof(yes)) == -1) {
107. ("setsockopt(): TCP_NODELAY %s\n", strerror(errno));
108. (cfd);
109. ;
110. }
111.  
112. (&ServerEvent, cfd, EV_READ | EV_PERSIST, ServerRead, NULL);
113. (&ServerEvent, NULL);
114.      
115. ("Accepted connection from %s\n", inet_ntoa(addr.sin_addr));
116. }
117.  
118. int NewSocket(void)
119. {
120. ;
121.  
122. //socket函数来创建一个能够进行网络通信的套接字。
123. //第一个参数指定应用程序使用的通信协议的协议族，对于TCP/IP协议族，该参数置AF_INET;
124. //第二个参数指定要创建的套接字类型
125. //流套接字类型为SOCK_STREAM、数据报套接字类型为SOCK_DGRAM、原始套接字SOCK_RAW
126. //第三个参数指定应用程序所使用的通信协议。
127. = socket(AF_INET, SOCK_STREAM, 0);
128. if (ServerSocket == -1) {
129. ("socket(): can not create server socket\n");
130. -1;
131. }
132.  
133. if (SetNonblock(ServerSocket) == -1) {
134. -1;
135. }
136.  
137. //清空内存数据
138. (&sa, 0, sizeof(sa));
139. .sin_family = AF_INET;
140. //htons将一个无符号短整型数值转换为网络字节序
141. .sin_port = htons(ListenPort);
142. //htonl将主机的无符号长整形数转换成网络字节顺序
143. .sin_addr.s_addr = htonl(ListenAddr);
144.  
145. //(struct sockaddr*)&sa将sa强制转换为sockaddr类型的指针
146. /*struct sockaddr 
147.          数据结构用做bind、connect、recvfrom、sendto等函数的参数，指明地址信息。
148.          但一般编程中并不直接针对此数据结构操作，而是使用另一个与sockaddr等价的数据结构 struct sockaddr_in
149.          sockaddr_in和sockaddr是并列的结构，指向sockaddr_in的结构体的指针也可以指向
150. ,
151.          在最后用进行类型转换就可以了
152. */
153. //bind函数用于将套接字绑定到一个已知的地址上
154. if (bind(ServerSocket, (struct sockaddr*)&sa, sizeof(sa)) == -1) {
155. (ServerSocket);
156. ("bind(): can not bind server socket");
157. -1;
158. }
159.      
160. //执行listen 之后套接字进入被动模式
161. //MaxConnections 连接请求队列的最大长度,队列满了以后，将拒绝新的连接请求
162. if (listen(ServerSocket, MaxConnections) == -1) {
163. ("listen(): can not listen server socket");
164. (ServerSocket);
165. -1;
166. }
167.  
168. /*
169.       event_set的参数：
170. + 参数1: 为要创建的event
171. + 参数2: file descriptor，创建纯计时器可以设置其为-1，即宏evtimer_set定义的那样
172. + 参数3: 设置event种类，常用的EV_READ, EV_WRITE, EV_PERSIST, EV_SIGNAL, EV_TIMEOUT，纯计时器设置该参数为0
173. + 参数4: event被激活之后触发的callback函数
174. + 参数5: 传递给callback函数的参数
175.       备注：
176. (设置了EV_PERSIST)，
177. (pending状态)，
178.              该event会持续保持pending状态，即该event可以无限次参加libevent的事件侦听。
179.              每当其被激活触发callback函数执行之后，该event自动从active转回为pending状态，
180. (当激活条件满足，又可以继续执行其callback)。
181. ()函数将该event从libevent的侦听事件集合中删除。
182.              如果不通过设置EV_PERSIST使得event是persistent的，需要在event的callback中再次调用event_add
183. (即在每次pending变为active之后，在callback中再将其设置为pending)
184. */
185. (&ServerEvent, ServerSocket, EV_READ | EV_PERSIST, ServerAccept, NULL);
186. //将event添加到libevent侦听的事件集中
187. if (event_add(&ServerEvent, 0) == -1) {
188. ("event_add(): can not add accept event into libevent");
189. (ServerSocket);
190. -1;
191. }
192. ;
193. }
194.  
195. int main(int argc, char *argv[])
196. {
197. int retval;
198.      
199. (); //初始化event base使用默认的全局current_base
200.      
201. = NewSocket();
202. if (retval == -1) {
203. exit(-1);
204. }
205.      
206. (); //启动事件队列系统，开始监听（并接受）请求
207.      
208. ;
209. }

编译

# gcc -o test test.c -levent

测试

# ./test

在另一终端启动

# telnet 127.0.0.1 8080