使用libevent库实现惊人的高并发C++服务器！_c++libevent的服务器开发

一、引言

在当今互联网时代，高并发服务器的需求越来越迫切。无论是面对日益增长的用户量、海量的请求还是高速的数据传输，构建一个能够优雅应对这些挑战的C++服务器变得至关重要。而幸运的是，有一个强大的利器——libevent库，它可以帮助实现惊人的高并发能力！

libevent库不仅仅是一个网络编程库，它是一个真正的加速器，为C++服务器注入无限的潜力。通过充分发挥libevent库的特性和功能，可以轻松地构建出一个能够处理百万级并发连接的服务器，实现超乎想象的性能和响应速度。

准备好了吗？手把手教你从0开始编写TCP服务器程序，体验开局一块砖，大厦全靠垒。

二、libevent简介

libevent是一个事件通知库，封装了reactor。

libevent API 提供了一种机制，用于在文件描述符上发生特定事件或达到超时后执行回调函数。此外，libevent还支持由于信号或常规超时而导致的回调。

libevent 旨在替换在事件驱动的网络服务器中找到的事件循环。应用程序只需要调用event_dispatch()，然后动态添加或删除事件，而无需更改事件循环。

目前，该控件支持/dev/poll, kqueue(), event ports, POSIX select(), Windows select(), poll()和epoll()。内部事件机制完全独立于公开的事件 API，并且 libevent 的简单更新可以提供新功能，而无需重新设计应用程序。因此，Libevent 允许可移植应用程序开发，并提供操作系统上可用的最具可扩展性的事件通知机制。libevent 还可用于多线程应用程序，方法是隔离每个event_base，以便只有单个线程访问它，或者锁定对单个共享event_base的访问。

libevent 还为缓冲网络 IO 提供了一个复杂的框架，支持套接字、筛选器、速率限制、SSL、零副本文件传输和 IOCP。自由度包括对几种有用协议的支持，包括 DNS、HTTP 和最小的 RPC 框架。

libevent编译安装，官网下载安装包并解压。进入解压目录执行：

wget https://github.com/libevent/libevent/releases/download/release-2.1.12-stable/libevent-2.1.12-stable.tar.gz
tar -zxvf libevent-2.1.12-stable.tar.gz 
cd libevent-2.1.12-stable
./configure 
make 
sudo make install
1
2
3
4
5
6

三、libevent库的封装层级

3.1、reactor对象封装struct event_base

reactor对象封装为struct event_base；通过：

（1）event_base_new()构造对象。

（2）event_base_free()销毁对象。

3.2、事件对象struct event

事件对象通过struct event的结构体封装使用。

struct event {
	struct event_callback ev_evcallback;

	/* for managing timeouts */
	union {
		TAILQ_ENTRY(event) ev_next_with_common_timeout;
		int min_heap_idx;
	} ev_timeout_pos;
	evutil_socket_t ev_fd;

	struct event_base *ev_base;

	union {
		/* used for io events */
		struct {
			LIST_ENTRY (event) ev_io_next;
			struct timeval ev_timeout;
		} ev_io;

		/* used by signal events */
		struct {
			LIST_ENTRY (event) ev_signal_next;
			short ev_ncalls;
			/* Allows deletes in callback */
			short *ev_pncalls;
		} ev_signal;
	} ev_;

	short ev_events;
	short ev_res;		/* result passed to event callback */
	struct timeval ev_timeout;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

通常，event对象可以自己处理IO。

（1）event_new()：构建事件对象、绑定、事件回调。

（2）event_free()：销毁事件对象。

bufferevent和evconnlistener对象只需要关注业务逻辑的处理，由libevent内部处理IO操作。

bufferevent是在event对象上面封装的缓冲区。

3.3、struct bufferevent对象

struct bufferevent中的重要成员变量：

struct bufferevent_ops中的重要成员变量：

（1）bufferevent_socket_new()：构建bufferevent对象。
（2）bufferevent_free()：销毁bufferevent对象。

3.4、evconnlistener对象

evconnlistener是专门处理listenfd的对象，使我们不需要关注bind、listen、accept的具体操作。

struct evconnlistener_ops {
	int (*enable)(struct evconnlistener *);
	int (*disable)(struct evconnlistener *);
	void (*destroy)(struct evconnlistener *);
	void (*shutdown)(struct evconnlistener *);
	evutil_socket_t (*getfd)(struct evconnlistener *);
	struct event_base *(*getbase)(struct evconnlistener *);
};

struct evconnlistener {
	const struct evconnlistener_ops *ops;
	void *lock;
	evconnlistener_cb cb;
	evconnlistener_errorcb errorcb;
	void *user_data;
	unsigned flags;
	short refcnt;
	int accept4_flags;
	unsigned enabled : 1;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

（1）evconnlistener_new()：构建evconnlistener对象、绑定、事件回调。

（2）evconnlistener_free()：销毁evconnlistener对象。

（3）evconnlistener_bind_new()：创建listenfd、bind、listen、注册读事件。

3.5、事件循环

（1）事件循环：event_base_dispatch()，event_base_loop()。

（2）事件循环退出：event_base_loopexit()，event_base_break()。

3.6、事件处理

设置事件相对应的回调。

（1）如果是使用event对象，在event_new()会设置相对应的回调。

（2）如果IO由libevent处理，那么使用bufferevent_setcb()来设置回调。

void
bufferevent_setcb(struct bufferevent *bufev,
    bufferevent_data_cb readcb, bufferevent_data_cb writecb,
    bufferevent_event_cb eventcb, void *cbarg)
{
	BEV_LOCK(bufev);

	bufev->readcb = readcb;
	bufev->writecb = writecb;
	bufev->errorcb = eventcb;

	bufev->cbarg = cbarg;
	BEV_UNLOCK(bufev);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

四、完整示例代码

#include <event.h>
#include <event2/listener.h>
#include <event2/buffer.h>

#include <sys/socket.h>

#include <functional>
#include <cstring>
#include <stdlib.h>


#define SOCKET_LISTEN_PORT  9703
#define SOCKET_BACKLOG_NUM  128

class asyn_event
{
private:
    
    /* data */
    struct event_base *base;
    struct evconnlistener *listener;
public:
    asyn_event(/* args */);
    ~asyn_event();
    static void accept_cb(struct evconnlistener *listen,evutil_socket_t fd,struct sockaddr *sock,int socklen,void *arg);
    static void socket_event_callback(struct bufferevent *bev, short events, void *arg);
    static void socket_read_callback(struct bufferevent *bev, void *arg);
    void loop_run();
};


asyn_event::asyn_event(/* args */)
{
    base=event_base_new();
    struct sockaddr_in server={0};
    server.sin_family=AF_INET;
    server.sin_addr.s_addr=htonl(INADDR_ANY);
    server.sin_port=htons(SOCKET_LISTEN_PORT);

    listener=evconnlistener_new_bind(
        base,
        &asyn_event::accept_cb,
        base,
        LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE,
        SOCKET_BACKLOG_NUM,
        (struct sockaddr*)&server,
        sizeof(server)
    );
}

asyn_event::~asyn_event()
{
    // 销毁evconnlistener对象
	evconnlistener_free(listener);

	// 销毁事件对象
	event_base_free(base);
}

void asyn_event::accept_cb(struct evconnlistener *listen,evutil_socket_t fd,struct sockaddr *sock,int socklen,void *arg)
{
	struct event_base *base = (struct event_base *)arg;

	// 连接的建立---接收连接
	char ip[32] = { 0 };
	evutil_inet_ntop(AF_INET, sock, ip, sizeof(ip) - 1);
	printf("accept a client fd:%d, ip:%s\n", fd, ip);

	struct bufferevent *bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
	
	// 注册读事件
	bufferevent_setcb(bev, socket_read_callback, NULL, socket_event_callback, NULL);//写事件回调一般为NULL
	bufferevent_enable(bev, EV_READ | EV_PERSIST);


}
void asyn_event::loop_run()
{
    // 事件循环
	event_base_dispatch(base);
}

// 处理连接断开
void asyn_event::socket_event_callback(struct bufferevent *bev, short events, void *arg)
{
	if (events &BEV_EVENT_EOF)//read=0
	{
		printf("connection closed\n");
	}
	else if (events & BEV_EVENT_ERROR)//strerro(errno)
	{
		printf("some other error\n");
	}
	else if (events &BEV_EVENT_TIMEOUT)
		printf("time out\n");

	bufferevent_free(bev);// close(fd)
}

// 读回调
void asyn_event::socket_read_callback(struct bufferevent *bev, void *arg)
{
    struct evbuffer *input = bufferevent_get_input(bev);
    struct evbuffer *output = bufferevent_get_output(bev);

    // 从输入缓冲区读取数据
    char buf[1024];
    size_t len;
    while ((len = evbuffer_remove(input, buf, sizeof(buf))) > 0) {
        //printf("Received: %.*s", (int)len, buf);
        evbuffer_add(output, buf, len);
    }
    
	//bufferevent_write(bev, reply, strlen(reply));
}

int main()
{
    asyn_event ev;
    ev.loop_run();
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

编译时要指定事件库，添加 -levent 参数。

gcc -o ev ev.c  -levent
1

运行时出现libevent-2.1.so.7。

error while loading shared libraries: libevent-2.1.so.7: cannot open shared object file: No such file or directory
1

产生原因：libevent动态库在默认安装时，存放的路径在/usr/local/lib下，不在系统的默认查找路径内。

解决办法有两个：

（1）将该路径放在系统查找路径内。这种方法仅永久有效。

sudo echo "/usr/local/lib" >> /etc/ld.so.conf
sudo ldconfig
1
2

（2）添加环境变量的方法，添加 export LD_LIBRARY_PATH=XXX。这种方法仅当前有效。

export LD_LIBRARY_PATH=/usr/local/lib/
1

五、总结

（1）有了libevent可以不使用IO函数。因为如果使用IO函数，既需要知道这些IO函数里面的系统调用返回值的含义。

（2）有了libevent就可以不清楚数据拷贝原理。

（3）有了libevent就可以不清楚网络原理以及网络编程流程。

（4）有了libevent只需要知道事件处理，IO操作完全交由libevent处理。

至此，我们实现了使用libevent库开发高并发的服务器程序，但是，这个服务器程序有些局限性，我们还要继续改善、优化。在改进之前，需要开发一个后台日志模块，这是服务器程序必须的，所有，下一个章节将开发一个高效的后台日志模块。