• libevent

    libevent

    库概念和特点

            开源。精简。跨平台（Windows、Linux、maxos、unix）。专注于网络通信（不一定非用在网络当中，比如下面的读写管道）。

            libevent特性：基于"事件"，面向“文件描述符”的异步（回调）通信模型。

            异步：函数"注册"时间和函数真正被执行的时间不同，函数真正是被内核调用(等待某一条件满足)

    【事件库：就干一件事，监听文件描述符的库机制。

            先创建一个事件底座，然后创建你想监听的时间，插到底座上，libevent底座就会帮忙监听事件，当事件发生时，就会自动调用事件的回调函数。】

    libevent使用框架

    常规事件

    常规事件函数
    1. //创建event_base(事件底座)
    2. struct event_base* base = event_base_new();
    3.  
    4. //创建事件event
    5. 常规事件event:event_new();
    6. 例如：
    7. struct event* signal_event = evsignal_new(base, SIGINT, signal_cb, (void *)base);
    8.  
    9. buffer event:bufferevent_socket_new();
    10.  
    11. //将事件添加到base上
    12. int event_add(struct event* ev, const struct timeval* tv);
    13.  
    14. //循环监听事件满足
    15. int event_base_dispatch(struct event_base* base);
    16. event_base_dispatch(base);					//调用
    17.  
    18. //释放event_base
    19. event_base_free(base);
    其他函数

     libevent函数使用的一个简单的例子：
    1. /*
    2.   This example program provides a trivial server program that listens for TCP
    3.   connections on port 9995.  When they arrive, it writes a short message to
    4.   each client connection, and closes each connection once it is flushed.
    6.   Where possible, it exits cleanly in response to a SIGINT (ctrl-c).
    7. */
    8.  
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #ifndef _WIN32
    14. #include 
    15. # ifdef _XOPEN_SOURCE_EXTENDED
    16. #  include 
    17. # endif
    18. #include 
    19. #endif
    20.  
    21. #include 
    22. #include 
    23. #include 
    24. #include 
    25. #include 
    26.  
    27. static const char MESSAGE[] = "Hello, World!\n";
    28.  
    29. static const int PORT = 9995;
    30.  
    31. static void listener_cb(struct evconnlistener *, evutil_socket_t,
    32.     struct sockaddr *, int socklen, void *);
    33. static void conn_writecb(struct bufferevent *, void *);
    34. static void conn_eventcb(struct bufferevent *, short, void *);
    35. static void signal_cb(evutil_socket_t, short, void *);
    36.  
    37. //main函数中是使用框架，剩下外面的函数就是事件的回调
    38. int main(int argc, char **argv)
    39. {//创建事件底座指针
    40. 	struct event_base *base;
    41. 	struct evconnlistener *listener;
    42. //创建事件指针
    43. 	struct event *signal_event;
    44. //创建套接字的地址结构
    45. 	struct sockaddr_in sin;
    46. #ifdef _WIN32
    47. 	WSADATA wsa_data;
    48. 	WSAStartup(0x0201, &wsa_data);
    49. #endif
    50. //真正创建事件底座
    51. 	base = event_base_new();
    52. 	if (!base) {
    53. 		fprintf(stderr, "Could not initialize libevent!\n");
    54. 		return 1;
    55. 	}
    56.  
    57. 	memset(&sin, 0, sizeof(sin));
    58. //初始化套接字的地址结构
    59. 	sin.sin_family = AF_INET;
    60. 	sin.sin_port = htons(PORT);
    61. //一个函数干了套接字通信的 socket、listen、bind、accept几个函数的事情
    62. 	listener = evconnlistener_new_bind(base, listener_cb, (void *)base,
    63. 	    LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE, -1,
    64. 	    (struct sockaddr*)&sin,
    65. 	    sizeof(sin));
    66.  
    67. 	if (!listener) {
    68. 		fprintf(stderr, "Could not create a listener!\n");
    69. 		return 1;
    70. 	}
    71. //注册一个信号事件
    72. 	signal_event = evsignal_new(base, SIGINT, signal_cb, (void *)base);
    73.  
    74. 	if (!signal_event || event_add(signal_event, NULL)<0) {
    75. 		fprintf(stderr, "Could not create/add a signal event!\n");
    76. 		return 1;
    77. 	}
    78. //循环监听，相当于 while循环加里面的epoll_wait；下面的循环有很大概率没有机会调用
    79. 	event_base_dispatch(base);
    80. //释放之前创建的事件
    81. 	evconnlistener_free(listener);
    82. 	event_free(signal_event);
    83. 	event_base_free(base);
    84.  
    85. 	printf("done\n");
    86. 	return 0;
    87. }
    88.  
    89. //下面是千篇一律，定义了三个回调，分别独立对应三个事件。看一个就行
    90. static void listener_cb(struct evconnlistener *listener, evutil_socket_t fd,
    91.     struct sockaddr *sa, int socklen, void *user_data)
    92. {
    93. 	struct event_base *base = user_data;
    94. 	struct bufferevent *bev;
    95.  
    96. 	bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
    97. 	if (!bev) {
    98. 		fprintf(stderr, "Error constructing bufferevent!");
    99. 		event_base_loopbreak(base);
    100. 		return;
    101. 	}
    102. 	bufferevent_setcb(bev, NULL, conn_writecb, conn_eventcb, NULL);
    103. 	bufferevent_enable(bev, EV_WRITE);
    104. 	bufferevent_disable(bev, EV_READ);
    105.  
    106. 	bufferevent_write(bev, MESSAGE, strlen(MESSAGE));
    107. }
    108.  
    109. static void conn_writecb(struct bufferevent *bev, void *user_data)
    110. {
    111. 	struct evbuffer *output = bufferevent_get_output(bev);
    112. 	if (evbuffer_get_length(output) == 0) {
    113. 		printf("flushed answer\n");
    114. 		bufferevent_free(bev);
    115. 	}
    116. }
    117.  
    118. static void conn_eventcb(struct bufferevent *bev, short events, void *user_data)
    119. {
    120. 	if (events & BEV_EVENT_EOF) {
    121. 		printf("Connection closed.\n");
    122. 	} else if (events & BEV_EVENT_ERROR) {
    123. 		printf("Got an error on the connection: %s\n",
    124. 		    strerror(errno));/*XXX win32*/
    125. 	}
    126. 	/* None of the other events can happen here, since we haven't enabled
    127. 	 * timeouts */
    128. 	bufferevent_free(bev);
    129. }
    130.  
    131. static void signal_cb(evutil_socket_t sig, short events, void *user_data)
    132. {
    133. 	struct event_base *base = user_data;
    134. 	struct timeval delay = { 2, 0 };
    135.  
    136. 	printf("Caught an interrupt signal; exiting cleanly in two seconds.\n");
    137.  
    138. 	event_base_loopexit(base, &delay);
    139. }
    常规事件函数使用详解
    *事件创建 event_new：
    1. struct event* event_new(struct event_base* base,evutil_socket_t fd,short what,event_callback_fd cb,void* arg);
    2. //
    3. 参数：
    4. base：基事件, 也就是event_base_new()的返回值
    5. fd：绑定到event上的文件描述符，监听的对象
    6. what：文件描述符对应的事件(r/w/e)，监听类型是什么
    7.     what的取值：
    8.         EV_READ：读一次后，退出循环
    9.         EV_WRITE：写一次，退出循环
    10.         EV_PERSIST：持续触发，可以理解为while(read())或while(write())
    11. cb：一旦满足监听条件，回调的函数
    12. arg：回调函数的参数
    13.  
    14. //返回值：成功返回创建的事件对象event
    15.
    事件回调函数：

    参数跟上面一致（实际用时候不用传参）

    1. typedef void (*event_callback_fn)(evutil_socket_t fd,short what,void* arg);
    2. f
    事件添加(到event_base上)：
    1. int event_add(struct event* ev,const strcut timeval* tv);
    2. //参数：
    3. ev是要添加的事件对象，就是event_new的返回值
    4. tv一般传NULL，表示一直等到事件被触发，回调函数才会被调用。如果传非0，会等待事件被触发，如果事件一直不触发，时间到，回调函数依然会被调用
    5.  
    6. //返回值：成功返回0；失败返回-1
    事件删除（对应add，从event_base上摘下事件(不常用)）：
    1. int event_del(struct event* ev);
    2. //ev是要摘下的事件对象，就是event_new的返回值
    事件销毁：
    1. int event_free(strcut event* ev);
    2. //ev是要销毁的事件对象，就是event_new的返回值
    基于libevent实现的FIFO的读写
    读FIFO进程：
    1. void perr_exit(const char* str) {
    2.     perror(str);
    3.     exit(1);
    4. }
    5. //读回调
    6. void read_cb(evutil_socket_t fd, short what, void* arg) {
    7.     char buf[BUFSIZ] = {0};
    8.     read(fd, buf, sizeof(buf));
    9.  
    10.     printf("Read from writer:%s\n", buf);
    11.     printf("what=%s\n", what & EV_READ ? "Yes" : "No");
    12.     sleep(1);
    13.  
    14.     return;
    15. }
    16.  
    17. int main(int argc, char* argv[]) {
    18.     int ret = 0;
    19.     int fd = 0;
    20.  
    21.     unlink("myfifo");
    22.     mkfifo("myfifo", 0644);
    23.  
    24.     fd = open("myfifo", O_RDONLY | O_NONBLOCK);//借助epoll反应堆，默认都是非阻塞
    25.     if (fd == -1)
    26.         perr_exit("open error");
    27. //读管道时候，管道中不一定有数据，此时就需要有事件概念介入了
    28. //创建事件基座
    29.     struct event_base* base = event_base_new();
    30.  
    31.     struct event* ev = NULL;
    32. //创建事件
    33.     ev = event_new(base, fd, EV_READ | EV_PERSIST, read_cb, NULL);
    34. //添加到事件基座
    35.     event_add(ev, NULL);
    36. //开启事件监听
    37.     event_base_dispatch(base);
    38. //释放事件
    39.     event_base_free(base);
    40.     close(fd);
    41.     return 0;
    42. }
    写FIFO进程：
    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. // 对操作处理函数
    11. void write_cb(evutil_socket_t fd, short what, void *arg)
    12. {
    13.     // write管道
    14.     char buf[1024] = {0};
    15.     
    16.     static int num = 0;
    17.     sprintf(buf, "hello,world-%d\n", num++);
    18.     write(fd, buf, strlen(buf)+1);
    19.     
    20.     sleep(1);
    21. }
    22.  
    23.  
    24. // 写管道
    25. int main(int argc, const char* argv[])
    26. {
    27.     // open file
    28.     //int fd = open("myfifo", O_WRONLY | O_NONBLOCK);
    29.     int fd = open("myfifo", O_WRONLY);
    30.     if(fd == -1)
    31.     {
    32.         perror("open error");
    33.         exit(1);
    34.     }
    35.  
    36.     // 写管道
    37.     struct event_base* base = NULL;
    38.     base = event_base_new();
    39.  
    40.     // 创建事件
    41.     struct event* ev = NULL;
    42.     // 检测的写缓冲区是否有空间写
    43.     //ev = event_new(base, fd, EV_WRITE , write_cb, NULL);
    44.     ev = event_new(base, fd, EV_WRITE | EV_PERSIST, write_cb, NULL);
    45.  
    46.     // 添加事件
    47.     event_add(ev, NULL);
    48.  
    49.     // 事件循环
    50.     event_base_dispatch(base);
    51.  
    52.     // 释放资源
    53.     event_free(ev);
    54.     event_base_free(base);
    55.     close(fd);
    56.     
    57.     return 0;
    58. }
     重点关注对写事件event_new函数入参，写监听时长的定义，写一次退出循环和一直触发的区别：

    libevent模型，事件的运行状态：未决和非未决

    未决：有资格被处理，但还没有被处理 （只剩数据没到达了）

    非未决：没有资格被处理 （除了数据没到达，还有其他监听条件没满足，比如事件没add）

    小注意：事件被处理完，如果设置了persist，add会被再调用一次
    在这里插入图片描述

    socket通信事件 bufferevent

    bufferevent概念

    bufferevent的事件对象fd有两个缓冲区。

    读：读缓冲区有数据，读回调函数被调用，使用bufferevent_read()读数据

    写：使用bufferevent_write，向写缓冲中写数据，该缓冲区中有数据自动写出，写完后，回调函数被调用(鸡肋)

    在这里插入图片描述

    原理：bufferent利用队列实现两个缓冲区(数据只能读一次，读走就没, FIFO)

    bufferevent事件对象创建和销毁
    创建socket事件对象 bufferevent_socket_new：
    1. struct bufferevent* bufferevent_socket_new(struct event_base* base,
    2.                                            evutil_socket_t fd,
    3.                                            enum bfferevent_options options)
    4. //入参
    5. base：基事件，event_base_new函数的返回值
    6. fd：封装到bufferevent内的fd(绑定在一起),即lfd
    7. enum表示枚举类型，一般取BEV_OPT_CLOSE_ON_FREE（关闭时释放底层套接字）
    8.  
    9. //返回
    10. 成功返回bufferevent事件对象

    对比event，有区别。这个不是在 new的时候设置的回调，而是借助后面的 bufferevent_setcb函数专门设置回调。

    销毁事件对象 bufferevent_socket_free：
    1. void bufferevent_socket_free(struct bufferevent* ev)
    2. //入参
    3. bufev：bufferevent_socket_new()函数的返回值
    5. readcb：读缓冲对应的回调，自己封装，在其内部读数据(注意是用bufferevent_read()读，而不是read())
    7. writecb：鸡肋，传NULL即可
    9. eventcb：可传NULL
    11. cbarg：回调函数的参数
    给bufferevent事件设置回调 bufferevent_setcb
    1. void bufferevent_setcb(struct bufferevent* bufev,
    2.                       bufferevent_data_cb readcb,
    3.                       bufferevent_data_cb writecb,
    4.                       bufferevent_event_cb eventcb,
    5.                       void* cbarg);
    6. //入参：
    7. bufev：bufferevent_socket_new()函数的返回值
    8.  
    9. readcb：读缓冲对应的回调，自己封装，在其内部读数据(注意是用bufferevent_read()读，而不是read())
    10.  
    11. writecb：鸡肋，传NULL即可
    12.  
    13. eventcb：备用回调，比如异常回调，也可传NULL
    14.  
    15. cbarg：三个回调函数的（相同）参数
     readcb对应的回调函数：

    1. void read_cb(struct bufferevent* bev,void* arg){
    2.     ...
    3.     bufferevent_read();
    4. }

    为什么 read_cb里面不封装read，因为没有fd给read传。fd通过new函数封装好的bufferevent传。

    size_t bufferevent_read(struct bufferevent* bufev,void* data,size_t size);
    writecb对应的回调函数：

    1. int bufferevent_write(struct bufferevent* bufev,const void* data,size_t size)
    eventcb对应的回调函数：
    1. typedef void (*bufferevent_event_cb)(struct bufferevent* bev,short events,void* ctx)

    buffer缓冲区开启和关闭

    默认新建的bufferevent写缓冲是enable的，而读缓冲是disable的

    通过下面函数操作缓冲区读写使能：

    1. void bufferevent_enable(struct bufferevent* bufev,short events);		//启用缓冲区
    2. void bufferevnet_disable(struct bufferevent* bufev,short events);		//禁用
    3.  
    4. /*例如:开启读缓冲*/
    5. void bufferevent_enable(bufev,EV_READ);
    6.  
    7. //events的值可传入三个宏：
    8. EV_READ
    9. EV_WRITE
    10. EV_READ|EV_WRITE

    也可获取缓冲区的禁用状态：

    1. short bufferevent_get_enable(struct bufferevent* bufev)
    客户端和服务器连接和监听函数详解
    客户端建立连接 bufferevent_socket_connect：
    1. int bufferevent_socket_connect(struct bufferevent* bev,struct sockaddr* address,int addrlen);
    2.  
    3. //入参
    4. bev：bufferevent事件对象(封装了fd)
    5. address，len：等同于connect()的参2和参3
    *服务器创建监听器对象 evconnlistener_new_bind （专门用于监听新链接）：

    这一个函数可以完成socket(),bind(),listen(),accept()四个函数的作用

    1. struct evconnlistener* evconnlistener_new_bind(struct event_base* base,
    2.                                                evconnlistener_cb cb,
    3.                                                void* ptr,
    4.                                                unsigned flags,
    5.                                                int backlog,
    6.                                                const struct sockaddr* sa,
    7.                                                int socklen);
    8. //入参
    9. cb：监听回调函数(建立连接后用户要做的操作)
    10. ptr：回调函数的参数
    11. flags：可识别的标志，通常传：
    12. ​ LEV_OPT_CLOSE_ON_FREE(释放bufferevent时关闭底层传输端口, 这将关闭底层套接字, 释放底层bufferevent等)
    13. ​ LEV_OPT_REUSEABLE(可以设置端口复用)
    14. backlog：相当于listen的参2,最大连接数， 传-1表示使用默认的最大值
    15. sa：服务器自己的地址结构
    16. socklen：sa的大小

    回调函数 evconnlistener_cb cb：

    监听成功后，说明客户端链接成功，原来的accept传出的客户端地址结构，现在在这里传出。

    1. typedef void (*evconnlistener_cb)(struct evconnlistener* listener,
    2.                                  evutil_socker_t sock,
    3.                                  struct sockaddr* addr,
    4.                                  int len,
    5.                                  void* ptr);
    6. //入参：
    7. listener：evconnlistener_new_bind 的返回值
    8. sock：用于通信的文件描述符，即cfd
    9. addr：传出，客户端的地址结构
    10. len：客户端地址结构的长度
    11. ptr：外部ptr传进来的值
    libevent实现TCP服务器流程

    • 创建基事件event_base
    • 使用evconlistener_new_bind()创建监听服务器，用来专门监听客户端链接事件，有新链接上来，就调用其回调函数（完成socket(),bind(),listen(),accept()四个函数的作用）
    • 设置evconlistener_new_bind()回调函数listner_cb()，该回调函数被调用，说明有一个新的客户端连接上来，会得到一个新的fd，用于跟客户端通信。
    • 创建bufferevent事件对象：bufferevent_socket_new()，将fd封装到这个事件对象中
    • 使用bufferevent_setcb()函数给bufferevent的read，write，event设置回调函数
    • 设置读写缓冲enable
    • 启动循环event_base_dispath()，监听通信事件（）
    • 当监听的事件满足时，read_cb会被调用，在其内部bufferevent_read()，读
    • 释放连接
    libevent实现TCP服务器源码分析
    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10.  
    11. // 读缓冲区回调
    12. void read_cb(struct bufferevent *bev, void *arg)
    13. {
    14.     char buf[1024] = {0};   
    15.     bufferevent_read(bev, buf, sizeof(buf));
    16.     printf("client say: %s\n", buf);
    17.  
    18.     char *p = "我是服务器, 已经成功收到你发送的数据!";
    19.     // 发数据给客户端
    20.     bufferevent_write(bev, p, strlen(p)+1);//执行完后回调write_cb
    21.     sleep(1);
    22. }
    23.  
    24. // 写缓冲区回调
    25. void write_cb(struct bufferevent *bev, void *arg)
    26. {
    27.     printf("I'm服务器, 成功写数据给客户端,写缓冲区回调函数被回调...\n"); 
    28. }
    29.  
    30. // 事件
    31. void event_cb(struct bufferevent *bev, short events, void *arg)
    32. {
    33.     if (events & BEV_EVENT_EOF)
    34.     {
    35.         printf("connection closed\n");  
    36.     }
    37.     else if(events & BEV_EVENT_ERROR)   
    38.     {
    39.         printf("some other error\n");
    40.     }
    41.     
    42.     bufferevent_free(bev);    
    43.     printf("buffevent 资源已经被释放...\n"); 
    44. }
    45.  
    46.  
    47.  
    48. void cb_listener(
    49.         struct evconnlistener *listener, 
    50.         evutil_socket_t fd, 
    51.         struct sockaddr *addr, 
    52.         int len, void *ptr)
    53. {
    54.    printf("connect new client\n");
    55.    struct event_base* base = (struct event_base*)ptr;
    56.  
    57. //创建出用于通信的socket事件对象bufferevent，并给bufferevent缓冲区设置回调和读使能
    58.    struct bufferevent *bev;
    59.    //2参fd被封装在新的事件对象 bufferevent中
    60.    bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
    61.    bufferevent_setcb(bev, read_cb, write_cb, event_cb, NULL);
    62.    bufferevent_enable(bev, EV_READ);
    63. }
    64.  
    65.  
    66. int main(int argc, const char* argv[])
    67. {
    68.  
    69.     // init server 
    70.     struct sockaddr_in serv;
    71.  
    72.     memset(&serv, 0, sizeof(serv));
    73.     serv.sin_family = AF_INET;
    74.     serv.sin_port = htons(9876);
    75.     serv.sin_addr.s_addr = htonl(INADDR_ANY);
    76.  
    77.     struct event_base* base;
    78.     base = event_base_new();
    79.     // 创建套接字
    80.     // 绑定
    81.     // 接收连接请求
    82.     struct evconnlistener* listener;
    83.     listener = evconnlistener_new_bind(base, cb_listener, base, 
    84.                                   LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE, 
    85.                                   36, (struct sockaddr*)&serv, sizeof(serv));
    86.  
    87.     event_base_dispatch(base);
    88.  
    89.     evconnlistener_free(listener);
    90.     event_base_free(base);
    91.  
    92.     return 0;
    93. }
    客户端流程简析和回顾
    1. 创建event_base
    2. 使用bufferevent_socket_new()创建一个用跟服务器通信的bufferevent事件对象
    3. 使用bufferevent_socket_connect连接服务器
    4. 使用bufferevent_setcb()给bufferevent对象的read，write，event设置回调
    5. 设置bufferevent对象的读写缓冲区使能 （4、5放connect前应该也没问题）
    6. 接受，发送数据bufferevent_read()/bufferevent_write()
    7. 启动循环监听event_base_dispath()
    8. 释放资源
    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10.  
    11. void read_cb(struct bufferevent *bev, void *arg)
    12. {
    13.     char buf[1024] = {0}; 
    14.     bufferevent_read(bev, buf, sizeof(buf));
    15.  
    16.     printf("fwq say:%s\n", buf);
    17.  
    18.     bufferevent_write(bev, buf, strlen(buf)+1);
    19.     sleep(1);
    20. }
    21.  
    22. void write_cb(struct bufferevent *bev, void *arg)
    23. {
    24.     printf("----------我是客户端的写回调函数,没卵用\n"); 
    25. }
    26.  
    27. void event_cb(struct bufferevent *bev, short events, void *arg)
    28. {
    29.     if (events & BEV_EVENT_EOF)
    30.     {
    31.         printf("connection closed\n");  
    32.     }
    33.     else if(events & BEV_EVENT_ERROR)   
    34.     {
    35.         printf("some other error\n");
    36.     }
    37.     else if(events & BEV_EVENT_CONNECTED)
    38.     {
    39.         printf("已经连接服务器...\\(^o^)/...\n");
    40.         return;
    41.     }
    42.     
    43.     // 释放资源
    44.     bufferevent_free(bev);
    45. }
    46.  
    47. // 客户端与用户交互，从终端读取数据写给服务器
    48. void read_terminal(evutil_socket_t fd, short what, void *arg)
    49. {
    50.     // 读数据
    51.     char buf[1024] = {0};
    52.     int len = read(fd, buf, sizeof(buf));
    53.  
    54.     struct bufferevent* bev = (struct bufferevent*)arg;
    55.     // 发送数据
    56.     bufferevent_write(bev, buf, len+1);
    57. }
    58.  
    59. int main(int argc, const char* argv[])
    60. {
    61.     struct event_base* base = NULL;
    62.     base = event_base_new();
    63.  
    64.     int fd = socket(AF_INET, SOCK_STREAM, 0);
    65.  
    66.     // 通信的fd放到bufferevent中
    67.     struct bufferevent* bev = NULL;
    68.     bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
    69.  
    70.     // init server info
    71.     struct sockaddr_in serv;
    72.     memset(&serv, 0, sizeof(serv));
    73.     serv.sin_family = AF_INET;
    74.     serv.sin_port = htons(9876);
    75.     inet_pton(AF_INET, "127.0.0.1", &serv.sin_addr.s_addr);
    76.  
    77.     // 连接服务器
    78.     bufferevent_socket_connect(bev, (struct sockaddr*)&serv, sizeof(serv));
    79.  
    80.     // 设置回调
    81.     bufferevent_setcb(bev, read_cb, write_cb, event_cb, NULL);
    82.  
    83.     // 设置读回调生效
    84. 	// bufferevent_enable(bev, EV_READ);
    85.  
    86.     // 创建事件
    87.     struct event* ev = event_new(base, STDIN_FILENO, EV_READ | EV_PERSIST,
    88.                                  read_terminal, bev);
    89.     // 添加事件                     
    90.     event_add(ev, NULL);
    91.  
    92.     event_base_dispatch(base);
    93.  
    94.     event_free(ev);
    95.     
    96.     event_base_free(base);
    97.  
    98.     return 0;
    99. }

    问自己：bufferevent和epoll反应堆的关系？？？ 

  • 相关阅读:
    信创平台：查询CPU,内存等命令
    Vue 项目前端响应式布局及框架搭建
    如何快速熟悉业务系统知识以及情况
    Microsoft Outlook Lite 引入短信功能
    c语言指针加减法
    promise
    goproxy实现windows的mysql的内网穿透
    phy调试2
    ARM 中常用的汇编指令解释汇总
    cx3588 文档说明
  • 原文地址：https://blog.csdn.net/weixin_46697509/article/details/134241870