Linux高并发服务器开发（十二）libevent

原创 于 2024-07-05 15:36:44 发布 · 849 阅读 · 8 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#服务器 #linux #学习 #tcp/ip #网络

文章目录

1 libevnt介绍

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2 event_base 结构体

相当于epoll中红黑树的节点

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
event_base 就是调用不同的多路IO接口判断事件是否已被激活，核心调用的是epoll，同时支持select和poll

获得当前使用的IO多路复用的方法
在这里插入图片描述
在这里插入图片描述

3 循环等待event_loop

在这里插入图片描述

一般使用另一个API
在这里插入图片描述

在这里插入图片描述

4 使用libevent库的步骤

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

5 基于event实现的tcp服务器编写思路

1.创建socket——socket()
2.设置端口复用 ——setsockopt(lfd, SOL_SOCKET, SOREUSEAADR, &opt, sizeof(int))
3.绑定——bind()
4.设置监听——listen()
5.创建地基——base = event_base_new();
struct event_base *base = event_base_new();
6.创建lfd对应的时间

struct event *ev = event_new(base, lfd, EV_READ| EV_PERSIST, conncb, **base**);
	// conncb 回调函数
	typedef void(*event_callback_fn)(evutil_socket_t fd, short events, void  *arg);
	// 监听文件描述符对应的事件回调函数
	void conncb(evutil_socket_t fd, short events, void  *arg)
	{
		struct event_base *base = (struct evnet_base *_)arg;
		// 接受新的连接
		int cfd = accpte();
		  if(cfd > 0)
		  {
		  	 	// 创建一格新的节点
		  	 	struct event *ev = event_new(**base**, lfd, EV|READ| EV|PERSIST, readcb,NULL);
		  	 	event_add(*ev, NULL);
		  }
	}
	
	// 读客户端数据对应的回调函数
	void readcb(evutil_socket_t fd, short events, void  *arg)
	{
		// 读数据
		n = read(fd, buf,sizeof(buf));
		if(n<=0)
		{
		// 从base地基上删除事件
		close(fd);
		event_del(ev);
		event_free(ev);
		}
		else
		{
		// 读数据
		}
｝

7.上event_base地基
event_add(ev, NULL);
8.进入事件循环
event_base_dispatch(base);
9.退出循环
event_base_free(base);
event_free(ev);

代码

这个代码有些问题，就是在对cfd下树时只会下最后一个cfd，可以按照select的数组方法进行优化

//编写libevent服务端
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>
#include <event2/event.h>

struct event *connev = NULL;
void readcb(evutil_socket_t fd, short events, void* arg)
{
    int n;
    char buf[1024];
    while(1)
    {   
        memset(buf, 0x00,sizeof(buf));
        n = read(fd, buf, sizeof(buf));
        if(n <= 0)
        {
            close(fd);
            event_del(connev);
            break;
        }
        write(fd, buf, n);
        

    }
}

void conncb(evutil_socket_t fd, short events, void* arg)
{
    struct event_base * base = (struct event_base*) arg;

    // 接受新的客户端连接
    int cfd = accept(fd, NULL, NULL);
    if(cfd > 0)
    {
        // 创建通信未见描述符对应的事件并设置回调函数位readcb
        connev = event_new(base, cfd, EV_READ | EV_PERSIST, readcb, NULL);
        if(connev == NULL)
        {
            // 退出循环
            event_base_loopexit(base, NULL);
        }

        // 将通信文件描述符对应的事件上event_base地基
        event_add(connev, NULL);
    }
}

int main()
{
    // 创建socket
    int lfd = socket(AF_INET, SOCK_STREAM, 0);

    // 设置端口复用
    int opt = 1;
    setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    // 绑定 
    struct sockaddr_in serv;
    bzero(&serv, sizeof(serv));
    serv.sin_family = AF_INET;
    serv.sin_addr.s_addr = htonl(INADDR_ANY);
    serv.sin_port = htons(8888);
    serv.sin_family =AF_INET;
    bind(lfd, (struct sockaddr*)&serv, sizeof(serv));

    // 监听 
    listen(lfd,128);

    // 创建地基
    struct event_base *base = event_base_new();
    if(base == NULL)
    {
        printf("event_base_new error\n");
        return -1;
    }
    // 创建监听文件描述符对应的事件
    struct event *ev = event_new(base, lfd, EV_READ | EV_PERSIST, conncb, base);
    if(ev == NULL)
    {
        printf("event_new error\n");
        return -1;
    }
    // 将新的事件节点上base地基
    event_add(ev, NULL);

    // 进入事件循环
    event_base_dispatch(base);

    // 释放资源
    event_base_free(base);
    event_free(ev);

    close(lfd);
    return 0;


    return 0;
}

6 bufferevent

自带buffer的事件，自带两个缓存区

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

相关函数

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

7 链接监听器 evconnlistener

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

8 libevent代码分析

/*
  This example program provides a trivial server program that listens for TCP
  connections on port 9995.  When they arrive, it writes a short message to
  each client connection, and closes each connection once it is flushed.

  Where possible, it exits cleanly in response to a SIGINT (ctrl-c).
*/


#include <string.h>
#include <errno.h>
#include <stdio.h>
#include <signal.h>
#ifndef _WIN32
#include <netinet/in.h>
# ifdef _XOPEN_SOURCE_EXTENDED
#  include <arpa/inet.h>
# endif
#include <sys/socket.h>
#endif

#include <event2/bufferevent.h>
#include <event2/buffer.h>
#include <event2/listener.h>
#include <event2/util.h>
#include <event2/event.h>
#include <ctype.h>

static const char MESSAGE[] = "Hello, World!\n";

static const int PORT = 9995;

static void listener_cb(struct evconnlistener *, evutil_socket_t,
    struct sockaddr *, int socklen, void *);
static void conn_writecb(struct bufferevent *, void *);
static void conn_eventcb(struct bufferevent *, short, void *);
static void signal_cb(evutil_socket_t, short, void *);

int
main(int argc, char **argv)
{
	struct event_base *base;	// 地基
	struct evconnlistener *listener;	// 链接监听器
	struct event *signal_event;		// 信号事件(树节点)

	struct sockaddr_in sin = {0};
#ifdef _WIN32
	WSADATA wsa_data;
	WSAStartup(0x0201, &wsa_data);
#endif

	// 创建地基，相当于epoll的树根epoll_create
	base = event_base_new();
	if (!base) {
		fprintf(stderr, "Could not initialize libevent!\n");
		return 1;
	}

	sin.sin_family = AF_INET;
	sin.sin_port = htons(PORT);

	// 创建链接监听器 ——socket——bind——listen——accpet
	// cb回调函数
	// LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE ：设置端口复用，当链接器释放时关闭文件描述符
	listener = evconnlistener_new_bind(base, listener_cb, (void *)base,
	    LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE, -1,
	    (struct sockaddr*)&sin,
	    sizeof(sin));

	if (!listener) {
		fprintf(stderr, "Could not create a listener!\n");
		return 1;
	}

	// 相当于event_new，设置signal_evnt的信号回调（signal_cb)
	signal_event = evsignal_new(base, SIGINT, signal_cb, (void *)base);

	if (!signal_event || event_add(signal_event, NULL)<0) {
		fprintf(stderr, "Could not create/add a signal event!\n");
		return 1;
	}

	// 等待事件循环，相当于while（1）

	event_base_dispatch(base);

	// 释放资源
	evconnlistener_free(listener);
	event_free(signal_event);
	event_base_free(base);

	printf("done\n");
	return 0;
}

// listener 链接监听器
// fd： 通信文件描述符
// sa和socklen：客户端IP地址信息
// user_data （void*)base
static void
listener_cb(struct evconnlistener *listener, evutil_socket_t fd,
    struct sockaddr *sa, int socklen, void *user_data)
{
	struct event_base *base = user_data;
	struct bufferevent *bev;

	// 创建bufferevent缓冲区
	// BEV_OPT_CLOSE_ON_FREE 释放的时候关闭通信
	bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
	if (!bev) {
		fprintf(stderr, "Error constructing bufferevent!");
		event_base_loopbreak(base);	// 退出循环，程序结束
		return;
	}
	// 设置回调函数
	bufferevent_setcb(bev, NULL, conn_writecb, conn_eventcb, NULL);
	// 使bufferevent生效 写生效
	bufferevent_enable(bev, EV_WRITE);
	// 读失效
	bufferevent_disable(bev, EV_READ);

	bufferevent_write(bev, MESSAGE, strlen(MESSAGE));
}

static void conn_readcb(struct bufferevent *bev, void *user_data)
{

	char buf[1024];
	memset(buf, 0x00, sizeof(buf));
	// 从bufferevent读数据
	int n = bufferevent_read(bev, buf, sizeof(buf));
	printf("n = [%d], buf == [%s]\n", n, buf);

	int i = 0;
	for(i = 0;i<n;i++)
	{
		buf[i] = toupper(buf[i]);
	}

	// 往bufferevent写缓冲区写数据,写缓存区会触发写回调函数
	bufferevent_write(bev, buf, sizeof(buf));


}


static void
conn_writecb(struct bufferevent *bev, void *user_data)
{
	struct evbuffer *output = bufferevent_get_output(bev);
	if (evbuffer_get_length(output) == 0) {
		printf("flushed answer\n");
		bufferevent_free(bev);
	}
}

static void
conn_eventcb(struct bufferevent *bev, short events, void *user_data)
{
	if (events & BEV_EVENT_EOF) {
		printf("Connection closed.\n");
	} else if (events & BEV_EVENT_ERROR) {
		printf("Got an error on the connection: %s\n",
		    strerror(errno));/*XXX win32*/
	}
	/* None of the other events can happen here, since we haven't enabled
	 * timeouts */
	bufferevent_free(bev);
}

static void
signal_cb(evutil_socket_t sig, short events, void *user_data)
{
	struct event_base *base = user_data;
	struct timeval delay = { 2, 0 };

	printf("Caught an interrupt signal; exiting cleanly in two seconds.\n");

	event_base_loopexit(base, &delay);
}

z

9 libevent服务端代码流程图分析

  1. 调用event_base_new 创建地基，base节点，然后调用evconnlistenr_new_bind函数—socket–setsockopt–bind-listen,如果有客户端链接请求，则在内部用accept函数接受新的客户端链接。在内部设置了回调函数:listen_cb
    在这里插入图片描述
    2.等待事件发生，调用event_base_dispatch函数进入循环

    listen_cb:调用buffevent_socket_new函数创建bufferevent，将通信文件描述符cfd和bufferevent捆绑在一起，然后调用bufferevent_setcb函数设置三个回调函数：读回调，写回调和事件回调。然后调用bufferevent_enable函数使设置生效
    conn_readcb:读bufferevent的读缓存区，读完后写应答数据到bufferevent到写缓存区，此时会触发写事件回调。
    conn_writecb:获得读bfferevent的读缓存区指针，然后判断读缓冲区中是否读完，若没有数据则数据已经发送完毕。

3.跳出循环资源释放
evconnlistener_free(listenr);
event_free(signal_event)
event_base_free(base);

在这里插入图片描述

10 libevent客户端代码流程图分析

//bufferevent建立客户端的过程
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <event.h>
#include <event2/bufferevent.h>
#include <event2/buffer.h>
#include <event2/util.h>

int tcp_connect_server(const char* server_ip, int port);
void cmd_msg_cb(int fd, short events, void* arg);
void server_msg_cb(struct bufferevent* bev, void* arg);
void event_cb(struct bufferevent *bev, short event, void *arg);

int main(int argc, char** argv)
{
    if( argc < 3 )
    {
        //两个参数依次是服务器端的IP地址、端口号
        printf("please input 2 parameter\n");
        return -1;
    }
    //创建根节点
    struct event_base *base = event_base_new();
    //创建并且初始化buffer缓冲区
    struct bufferevent* bev = bufferevent_socket_new(base, -1,
                                                     BEV_OPT_CLOSE_ON_FREE);

    //监听终端输入事件 设置标准输入的监控,设置回调是 cmd_msg_cb 
    struct event* ev_cmd = event_new(base, STDIN_FILENO,
                                     EV_READ | EV_PERSIST,
                                     cmd_msg_cb, (void*)bev);
    //上树 开始监听标准输入的读事件
    event_add(ev_cmd, NULL);
    
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr) );
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(atoi(argv[2]));
    //将ip地址转换为网络字节序
    inet_aton(argv[1], &server_addr.sin_addr);

    //连接到 服务器ip地址和端口 初始化了 socket文件描述符 socket+connect 
    bufferevent_socket_connect(bev, (struct sockaddr *)&server_addr,
                               sizeof(server_addr));
    //设置buffer的回调函数 主要设置了读回调 server_msg_cb ,传入参数是标准输入的读事件
    bufferevent_setcb(bev, server_msg_cb, NULL, event_cb, (void*)ev_cmd);
    bufferevent_enable(bev, EV_READ | EV_PERSIST);

    event_base_dispatch(base);//循环等待
    event_free(ev_cmd);
    bufferevent_free(bev);
    event_base_free(base);
    printf("finished \n");
    return 0;
}
//终端输入回调
void cmd_msg_cb(int fd, short events, void* arg)
{
    char msg[1024];

    int ret = read(fd, msg, sizeof(msg));
    if( ret < 0 )
    {
        perror("read fail ");
        exit(1);
    }
    //得到bufferevent指针,目的是为了写到bufferevent的写缓冲区
    struct bufferevent* bev = (struct bufferevent*)arg;

    //把终端的消息发送给服务器端
    bufferevent_write(bev, msg, ret);
}

void server_msg_cb(struct bufferevent* bev, void* arg)
{
    char msg[1024];

    size_t len = bufferevent_read(bev, msg, sizeof(msg));
    msg[len] = '\0';

    printf("recv %s from server\n", msg);
}

void event_cb(struct bufferevent *bev, short event, void *arg)
{

    if (event & BEV_EVENT_EOF)
        printf("connection closed\n");
    else if (event & BEV_EVENT_ERROR)
        printf("some other error\n");
    else if( event & BEV_EVENT_CONNECTED)
    {
        printf("the client has connected to server\n");
        return ;
    }

    //这将自动close套接字和free读写缓冲区
    bufferevent_free(bev);
    //释放event事件 监控读终端
    struct event *ev = (struct event*)arg;
    event_free(ev);
}
千殃sama
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值