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

作者: QxQx | 来源:发表于2021-03-14 13:58 被阅读0次

linux下 C++ 使用 epoll 多路复用实现高性能的t
自己动手实现Epoll
epoll知识点总结
linux epoll解析
Java多线程：Linux多路复用，Java NIO与Netty
Linux下I/O多路复用select, poll, epoll
Python57_epoll实现HTTP
IO多路复用详解
Linux Epoll 一网打尽
Epoll模型（笔记）

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

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

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

工具

文中使用的开发环境

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

准备知识

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

epoll_create(int __size) 创建一个epoll，_size 参数在linux2.6内核之后就没有什么作用了, 但是要>0，一般直接填 1 就好了。函数返回创建的epoll的文件描述符，如果创建失败，会返回 -1。
epoll_ctl(nt __epfd, int __op, int __fd,struct epoll_event *__event) 操作已有的epoll,epfdepoll的文件描述符；op操作方式，有添加、删除、修改等等；_fd 要操作对象的描述符，如果是操作tcp连接，也会就是这个连接的描述符。_event epoll 的响应事件，当epoll管理的tcp连接有事件发生时，会通过 _event 这个对象传递出来，所以在添加连接时，要把这个连接包装成一个 epoll_event 对象 </br>
- op 类型
- EPOLL_CTL_ADD 添加一个描述符
- EPOLL_CTL_DEL 删除一个描述符
- EPOLL_CTL_MOD 修改一个描述符
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)：</br>

LT(level triggered，水平触发模式)是默认的工作方式，并且同时支持 block 和 non-block socket。在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果你不作任何操作，内核还是会继续通知你的，所以，这种模式编程出错误可能性要小一点。
ET(edge-triggered，边缘触发模式)是高速工作方式，只支持no-block socket。在这种模式下，当描述符从未就绪变为就绪时，内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪，并且不会再为那个文件描述符发送更多的就绪通知，等到下次有新的数据进来的时候才会再次出发就绪事件。

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

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

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

epoll原理

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

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

简单的epoll实现

#include <iostream>//控制台输出
#include <sys/socket.h>//创建socket
#include <netinet/in.h>//socket addr
#include <sys/epoll.h>//epoll
#include <unistd.h>//close函数
#include <fcntl.h>//设置非阻塞

using namespace std;

int main() {
    const int EVENTS_SIZE = 20;
    //读socket的数组
    char buff[1024];

    //创建一个tcp socket
    int socketFd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

    //设置socket监听的地址和端口
    sockaddr_in sockAddr{};
    sockAddr.sin_port = htons(8088);
    sockAddr.sin_family = AF_INET;
    sockAddr.sin_addr.s_addr = htons(INADDR_ANY);

    //将socket和地址绑定
    if (bind(socketFd, (sockaddr *) &sockAddr, sizeof(sockAddr)) == -1) {
        cout << "bind error" << endl;
        return -1;
    }

    //开始监听socket,当调用listen之后,
    //进程就可以调用accept来接受一个外来的请求
    //第二个参数,请求队列的长度
    if (listen(socketFd, 10) == -1) {
        cout << "listen error" << endl;
        return -1;
    }

    //创建一个epoll,size已经不起作用了,一般填1就好了
    int eFd = epoll_create(1);

    //把socket包装成一个epoll_event对象
    //并添加到epoll中
    epoll_event epev{};
    epev.events = EPOLLIN;//可以响应的事件,这里只响应可读就可以了
    epev.data.fd = socketFd;//socket的文件描述符
    epoll_ctl(eFd, EPOLL_CTL_ADD, socketFd, &epev);//添加到epoll中
    
    //回调事件的数组,当epoll中有响应事件时,通过这个数组返回
    epoll_event events[EVENTS_SIZE];

    //整个epoll_wait 处理都要在一个死循环中处理
    while (true) {
        //这个函数会阻塞,直到超时或者有响应事件发生
        int eNum = epoll_wait(eFd, events, EVENTS_SIZE, -1);

        if (eNum == -1) {
            cout << "epoll_wait" << endl;
            return -1;
        }
        //遍历所有的事件
        for (int i = 0; i < eNum; i++) {
            //判断这次是不是socket可读(是不是有新的连接)
            if (events[i].data.fd == socketFd) {
                if (events[i].events & EPOLLIN) {
                    sockaddr_in cli_addr{};
                    socklen_t length = sizeof(cli_addr);
                    //接受来自socket连接
                    int fd = accept(socketFd, (sockaddr *) &cli_addr, &length);
                    if (fd > 0) {
                        //设置响应事件,设置可读和边缘(ET)模式
                        //很多人会把可写事件(EPOLLOUT)也注册了,后面会解释
                        epev.events = EPOLLIN | EPOLLET;
                        epev.data.fd = fd;
                        //设置连接为非阻塞模式
                        int flags = fcntl(fd, F_GETFL, 0);
                        if (flags < 0) {
                            cout << "set no block error, fd:" << fd << endl;
                            continue;
                        }
                        if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) {
                            cout << "set no block error, fd:" << fd << endl;
                            continue;
                        }
                        //将新的连接添加到epoll中
                        epoll_ctl(eFd, EPOLL_CTL_ADD, fd, &epev);
                        cout << "client on line fd:" << fd << endl;
                    }
                }
            } else {//不是socket的响应事件
                
                //判断是不是断开和连接出错
                //因为连接断开和出错时,也会响应`EPOLLIN`事件
                if (events[i].events & EPOLLERR || events[i].events & EPOLLHUP) {
                    //出错时,从epoll中删除对应的连接
                    //第一个是要操作的epoll的描述符
                    //因为是删除,所有event参数天null就可以了
                    epoll_ctl(eFd, EPOLL_CTL_DEL, events[i].data.fd, nullptr);
                    cout << "client out fd:" << events[i].data.fd << endl;
                    close(events[i].data.fd);
                } else if (events[i].events & EPOLLIN) {//如果是可读事件
                    
                    //如果在windows中,读socket中的数据要用recv()函数
                    int len = read(events[i].data.fd, buff, sizeof(buff));
                    //如果读取数据出错,关闭并从epoll中删除连接
                    if (len == -1) {
                        epoll_ctl(eFd, EPOLL_CTL_DEL, events[i].data.fd, nullptr);
                        cout << "client out fd:" << events[i].data.fd << endl;
                        close(events[i].data.fd);
                    } else {
                        //正常读取,打印读到的数据
                        cout << buff << endl;
                        
                        //向客户端发数据
                        char a[] = "123456";
                        //如果在windows中,向socket中写数据要用send()函数
                        write(events[i].data.fd, a, sizeof(a));
                    }
                }
            }
        }
    }
}

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

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

但是经过测试，不注册可写事件，直接往socket中写也是可以的

经过查资料得知:

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

客户端测试

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

package main

import (
    "fmt"
    "net"
    "sync"
    "time"
)

const (
    MAX_CONN = 10
)

func main() {
    var wg sync.WaitGroup
    wg.Add(1)
    for i := 0; i < MAX_CONN; i++ {
        go Conn("192.168.199.164:8088", i)
        time.Sleep(time.Millisecond * 100)
    }
    wg.Wait()
}

func Conn(addr string, id int) {
    conn, err := net.Dial("tcp", addr)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("connect ", id)
    go func() {
        buf := make([]byte, 1024)
        for {
            n, err := conn.Read(buf)
            if err != nil {
                break
            }
            fmt.Println(id, "read: ", string(buf[:n]))
        }
    }()
    time.Sleep(time.Second * 1)
    for {
        _, err := conn.Write([]byte("hello"))
        if err != nil {
            break
        }
        time.Sleep(time.Second * 10)
    }
}

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

服务端打印信息

服务端

客户端打印信息

客户端

总结

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

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

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

linux下 C++ 使用 epoll 多路复用实现高性能的t
linux系统中，实现socket多路复用的技术有select 、poll 、epoll 等多种方式。这些不同方式...
自己动手实现Epoll
Epoll是Linux IO多路复用的管理机制。作为现在Linux平台高性能网络IO必要的组件。内核的实现可以参照...
epoll知识点总结
epoll是linux IO多路复用的管理机制，现在是linux平台高性能网络io必要的组件。理解内核epoll...
linux epoll解析
linux epoll 引言高性能网络编程避免不了与epoll打交道，epoll是一种IO多路复用技术，可以非常...
Java多线程：Linux多路复用，Java NIO与Netty
JVM的多路复用器实现原理 Linux 2.5以前：select/poll Linux 2.6以后: epoll ...
Linux下I/O多路复用select, poll, epoll
Linux下I/O多路复用select, poll, epoll 三种模型 select, poll, epoll...
Python57_epoll实现HTTP
ps：epoll是Linux中使用的 IO多路复用就是我们说的select, pll, epoll，有些地方也称...
IO多路复用详解
IO多路复用详解 IO多路复用的实现方式我们这里只讨论linux两个典型的实现，select和epoll sel...
Linux Epoll 一网打尽
前言 epoll同样是linux上的IO多路复用的一种实现，内核在实现时使用的数据结构相比select要复杂，但原...
Epoll模型（笔记）
Epoll是select和poll的升级版，方便实现linux下可以I/O多路复用，是目前最高效的能降低在高并发少...