C++ 网络 linux

linux下 C++ 使用 epoll 多路复用 实现高性能的tcpserver

linux系统中，实现socket多路复用的技术有select 、poll 、epoll 等多种方式。这些不同方式个有优缺点和适用场景，这不是本文讨论的重点，又兴趣的可以自己搜索学习一下。但是在高并发场景下， epoll 性能是最高的， Nginx 都听说过吧，大名鼎鼎的Nginx 底层用的就是 epoll。

这篇文章主要是写怎么用 epoll，而不是原理分析。这篇文章不是最全的，也不是最深入的，但是绝对是一篇能让普通人看懂的，看完能自己用epoll写出一个tcpserver的文章。全废话不多说，直接开始搞

首先明确一点，epoll 是linux系统提供的系统调用，也就说，epoll 在Windows系统上是没法使用的，相应的代码也是没法编译的。如果有人知道怎么在Windows中编译，请赐教。

工具

文中使用的开发环境

  1. 系统: Debian GNU/Linux 10 (buster)
  2. linux内核: 4.19.0-14
  3. gcc版本: 8.3.0

准备知识

epoll是linux内核提供的功能，这个功能对外提供系统调用，在C/C++中通过三个函数对用户提供功能

  1. epoll_create(int __size) 创建一个epoll，_size 参数在linux2.6内核之后就没有什么作用了, 但是要>0，一般直接填 1 就好了。函数返回创建的epoll的文件描述符，如果创建失败，会返回 -1。

  2. epoll_ctl(nt __epfd, int __op, int __fd,struct epoll_event *__event) 操作已有的epoll,epfdepoll的文件描述符；op操作方式，有添加、删除、修改等等；_fd 要操作对象的描述符，如果是操作tcp连接，也会就是这个连接的描述符。_event epoll 的响应事件，当epoll管理的tcp连接有事件发生时，会通过 _event 这个对象传递出来，所以在添加连接时，要把这个连接包装成一个 epoll_event 对象

    • op 类型
    • EPOLL_CTL_ADD 添加一个描述符
    • EPOLL_CTL_DEL 删除一个描述符
    • EPOLL_CTL_MOD 修改一个描述符

  3. epoll_wait(int __epfd, struct epoll_event *__events,int __maxevents, int __timeout) 当epoll管理的连接中有响应事件发生时,会回调这个函数。epfdepoll的文件描述符；__events 可以操作的连接数组；__maxevents 一个可以处理的最大事件数量；__timeout 超时时间（单位毫秒），如果填-1，会直到有可操作事件发生时才会返回，因为C++不支持函数多返回值，像Go可以直接返回所有事件和数量了 (╥╯^╰╥)。

    events 中的常用的类型：

    • EPOLLIN ：表示对应的文件描述符可以读（SOCKET正常关闭）
    • EPOLLOUT：表示对应的文件描述符可以写
    • EPOLLPRI：表示对应的文件描述符有紧急的数据可读（表示有带外数据到来）
    • EPOLLERR：表示对应的文件描述符发生错误(默认注册)
    • EPOLLHUP：表示对应的文件描述符被挂断(默认注册)
    • EPOLLET： 将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)来说的
    • EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里 是不是很惊奇，这么牛逼的epoll就三个函数，第一次看到的时候我也觉得很奇怪，三个函数就能搞定那么复杂的事情。不过想想也是，把复杂的东西简化，才能体现出大神的实力

epoll的两种模式

epoll 事件有两种模型 Level Triggered (LT) 和 Edge Triggered (ET)：

  • LT(level triggered，水平触发模式)是默认的工作方式，并且同时支持 block 和 non-block socket。在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果你不作任何操作，内核还是会继续通知你的，所以，这种模式编程出错误可能性要小一点。

  • ET(edge-triggered，边缘触发模式)是高速工作方式，只支持no-block socket。在这种模式下，当描述符从未就绪变为就绪时，内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪，并且不会再为那个文件描述符发送更多的就绪通知，等到下次有新的数据进来的时候才会再次出发就绪事件。

把socket设置为非阻塞模式的方法

1int flags = fcntl(fd, F_GETFL, 0);
2fcntl(fd, F_SETFL, flags | O_NONBLOCK);

需要的头文件 #include <fcntl.h>

epoll原理

简单通过画图解释一下epoll的工作原理

这里没有涉及太底层的东西，因为太底层的我也没研究过，不敢乱讲。知之为知之，不知为不知。
epoll可以看做是一个由操作系统提供的容器，这个容器管理了一些 epoll_event （图中我画成单向链表了，实际上用的是红黑树，因为画树太麻烦了），这个event是我们添加进去的，event中设置了要响应的事件类型，当epoll 检测到具体的 event 有对应的事件发生时，会通过epoll_wait() 通知。

简单的epoll实现

  1#include <iostream>//控制台输出
  2#include <sys/socket.h>//创建socket
  3#include <netinet/in.h>//socket addr
  4#include <sys/epoll.h>//epoll
  5#include <unistd.h>//close函数
  6#include <fcntl.h>//设置非阻塞
  7
  8using namespace std;
  9
 10int main() {
 11    const int EVENTS_SIZE = 20;
 12    //读socket的数组
 13    char buff[1024];
 14
 15    //创建一个tcp socket
 16    int socketFd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 17
 18    //设置socket监听的地址和端口
 19    sockaddr_in sockAddr{};
 20    sockAddr.sin_port = htons(8088);
 21    sockAddr.sin_family = AF_INET;
 22    sockAddr.sin_addr.s_addr = htons(INADDR_ANY);
 23
 24    //将socket和地址绑定
 25    if (bind(socketFd, (sockaddr *) &sockAddr, sizeof(sockAddr)) == -1) {
 26        cout << "bind error" << endl;
 27        return -1;
 28    }
 29
 30    //开始监听socket,当调用listen之后,
 31    //进程就可以调用accept来接受一个外来的请求
 32    //第二个参数,请求队列的长度
 33    if (listen(socketFd, 10) == -1) {
 34        cout << "listen error" << endl;
 35        return -1;
 36    }
 37
 38    //创建一个epoll,size已经不起作用了,一般填1就好了
 39    int eFd = epoll_create(1);
 40
 41    //把socket包装成一个epoll_event对象
 42    //并添加到epoll中
 43    epoll_event epev{};
 44    epev.events = EPOLLIN;//可以响应的事件,这里只响应可读就可以了
 45    epev.data.fd = socketFd;//socket的文件描述符
 46    epoll_ctl(eFd, EPOLL_CTL_ADD, socketFd, &epev);//添加到epoll中
 47    
 48    //回调事件的数组,当epoll中有响应事件时,通过这个数组返回
 49    epoll_event events[EVENTS_SIZE];
 50
 51    //整个epoll_wait 处理都要在一个死循环中处理
 52    while (true) {
 53        //这个函数会阻塞,直到超时或者有响应事件发生
 54        int eNum = epoll_wait(eFd, events, EVENTS_SIZE, -1);
 55
 56        if (eNum == -1) {
 57            cout << "epoll_wait" << endl;
 58            return -1;
 59        }
 60        //遍历所有的事件
 61        for (int i = 0; i < eNum; i++) {
 62            //判断这次是不是socket可读(是不是有新的连接)
 63            if (events[i].data.fd == socketFd) {
 64                if (events[i].events & EPOLLIN) {
 65                    sockaddr_in cli_addr{};
 66                    socklen_t length = sizeof(cli_addr);
 67                    //接受来自socket连接
 68                    int fd = accept(socketFd, (sockaddr *) &cli_addr, &length);
 69                    if (fd > 0) {
 70                        //设置响应事件,设置可读和边缘(ET)模式
 71                        //很多人会把可写事件(EPOLLOUT)也注册了,后面会解释
 72                        epev.events = EPOLLIN | EPOLLET;
 73                        epev.data.fd = fd;
 74                        //设置连接为非阻塞模式
 75                        int flags = fcntl(fd, F_GETFL, 0);
 76                        if (flags < 0) {
 77                            cout << "set no block error, fd:" << fd << endl;
 78                            continue;
 79                        }
 80                        if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) {
 81                            cout << "set no block error, fd:" << fd << endl;
 82                            continue;
 83                        }
 84                        //将新的连接添加到epoll中
 85                        epoll_ctl(eFd, EPOLL_CTL_ADD, fd, &epev);
 86                        cout << "client on line fd:" << fd << endl;
 87                    }
 88                }
 89            } else {//不是socket的响应事件
 90                
 91                //判断是不是断开和连接出错
 92                //因为连接断开和出错时,也会响应`EPOLLIN`事件
 93                if (events[i].events & EPOLLERR || events[i].events & EPOLLHUP) {
 94                    //出错时,从epoll中删除对应的连接
 95                    //第一个是要操作的epoll的描述符
 96                    //因为是删除,所有event参数天null就可以了
 97                    epoll_ctl(eFd, EPOLL_CTL_DEL, events[i].data.fd, nullptr);
 98                    cout << "client out fd:" << events[i].data.fd << endl;
 99                    close(events[i].data.fd);
100                } else if (events[i].events & EPOLLIN) {//如果是可读事件
101                    
102                    //如果在windows中,读socket中的数据要用recv()函数
103                    int len = read(events[i].data.fd, buff, sizeof(buff));
104                    //如果读取数据出错,关闭并从epoll中删除连接
105                    if (len == -1) {
106                        epoll_ctl(eFd, EPOLL_CTL_DEL, events[i].data.fd, nullptr);
107                        cout << "client out fd:" << events[i].data.fd << endl;
108                        close(events[i].data.fd);
109                    } else {
110                        //正常读取,打印读到的数据
111                        cout << buff << endl;
112                        
113                        //向客户端发数据
114                        char a[] = "123456";
115                        //如果在windows中,向socket中写数据要用send()函数
116                        write(events[i].data.fd, a, sizeof(a));
117                    }
118                }
119            }
120        }
121    }
122}

常见的问题和注意事项在注释中，就单解释一下新连接注册事件的问题吧，很多文章中都会把可写事件也注册进去，像这样

 1sockaddr_in cli_addr{};
 2socklen_t length = sizeof(cli_addr);
 3//接受来自socket连接
 4int fd = accept(socketFd, (sockaddr *) &cli_addr, &length);
 5if (fd > 0) {
 6	epev.events = EPOLLIN | EPOLLET | EPOLLOUT;
 7	epev.data.fd = fd;
 8	epoll_ctl(eFd, EPOLL_CTL_ADD, fd, &epev);
 9	cout << "client on line fd:" << fd << endl;
10}

但是经过测试，不注册可写事件，直接往socket中写也是可以的
经过查资料得知:

  • EPOLLIN : 如果状态改变了(比如 从无到有)，只要输入缓冲区可读就会触发
  • EPOLLOUT : 如果状态改变了(比如 从满到不满)，只要输出缓冲区可写就会触 如果把可写也注册上，会频繁回调，这里会有很多无用的回调，导致性能下降。 有一种思路，当向socket写失败后（write函数返回值 == -1），注册上 EPOLLOUT 当响应了可写事件后，重新往socket中写数据，写成功后，再取消掉 EPOLLOUT。 这里就不给出示例了

客户端测试

这次关注的是服务端实现，客户端就不用C++写了，用Go写了一个client（没别的原因，只是因为Go写起了简单）

 1package main
 2
 3import (
 4	"fmt"
 5	"net"
 6	"sync"
 7	"time"
 8)
 9
10const (
11	MAX_CONN = 10
12)
13
14func main() {
15	var wg sync.WaitGroup
16	wg.Add(1)
17	for i := 0; i < MAX_CONN; i++ {
18		go Conn("192.168.199.164:8088", i)
19		time.Sleep(time.Millisecond * 100)
20	}
21	wg.Wait()
22}
23
24func Conn(addr string, id int) {
25	conn, err := net.Dial("tcp", addr)
26	if err != nil {
27		fmt.Println(err)
28		return
29	}
30	fmt.Println("connect ", id)
31	go func() {
32		buf := make([]byte, 1024)
33		for {
34			n, err := conn.Read(buf)
35			if err != nil {
36				break
37			}
38			fmt.Println(id, "read: ", string(buf[:n]))
39		}
40	}()
41	time.Sleep(time.Second * 1)
42	for {
43		_, err := conn.Write([]byte("hello"))
44		if err != nil {
45			break
46		}
47		time.Sleep(time.Second * 10)
48	}
49}

这只是一个测试用的，写的很粗糙，但是不影响使用

服务端打印信息

服务端

客户端打印信息

客户端

总结

  1. epoll是socket多路复用技术的一种，还有select和poll
  2. epoll 只能在linux使用(Windows下怎么用我没找到,如果说错了请指正)
  3. epoll 事件有 Level Triggered (LT) 和 Edge Triggered (ET) 两种模型，LT是默认模式，ET是高性能模式

另外，我使用面向对象的方式封装了一个epoll的tcpserver 代码有点多，就不贴在这了，已经上传 github 码云

欢迎给点个star ヾ(o◕∀◕)ﾉヾ

© 2021 - 2024 QX 的笔记
发表了55篇文章 · 总计119.18k字
本博客已稳定运行
© QX
使用 Hugo 构建
主题 Stack 由 Jimmy 设计