• 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. #include <event.h>
    3. #include <stdio.h>
    4. int main()
    5. {
    6.     const char *version = event_get_version();
    7.     printf("%s\n",version);
    8.     return 0;
    9. }


    2、timer程序

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


    3、socket程序

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


    编译
    # gcc -o test test.c -levent

    测试
    # ./test
    在另一终端启动
    # telnet 127.0.0.1 8080

  • 相关阅读:
    avcodec_open2()分析
    CentOS 6.9 下安装DB2
    使用python操作mysql数据库
    python之tcp自动重连
    决策树算法
    文件夹自动同步工具
    KNN算法介绍
    go语言生成uuid
    golang之log rotate
    golang之tcp自动重连
  • 原文地址:https://www.cnblogs.com/UnGeek/p/2992538.html
Copyright © 2020-2023  润新知