epoll比select和poll究竟高效在哪儿（剖析及实现）

最新推荐文章于 2022-10-05 13:30:27 发布
最新推荐文章于 2022-10-05 13:30:27 发布
阅读量619 收藏 1
点赞数
分类专栏： Linux网络通信 文章标签： linux 数据库 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zsiming/article/details/126764918
版权
本文详细介绍了IO复用模型中的select、poll和epoll三种方法，并对比了它们的优缺点。select存在文件描述符数量限制和效率低的问题，poll使用链表管理文件描述符，而epoll利用红黑树提高效率并减少拷贝操作。epoll的ET和LT模式在处理就绪事件上有不同策略，ET要求一次性读完，LT则在事件发生时持续通知。
摘要由CSDN通过智能技术生成

文章目录

1. 理论背景

​ 它们都是IO复用的系统调用。

  1. 对于select的使用，用户需要传入三个用于监听可读、可写、异常的，基于数组实现的文件描述符集合。在事件发生之后，会返回就绪文件描述符的总数。那么用户需要分别遍历这三个数组来判断哪些文件描述符哪种事件就绪，进行业务处理。在下次监听时，需要重置这三个数组才能重新监听，因为这三个需要监听的数组已经被内核修改过了。

    那么，从这里看出，在标记跟取出就绪的文件描述符时，都需要遍历整个文件描述符集合。而且这些集合需要从用户态拷贝到内核态，然后又从内核态拷贝回用户态，效率比较低。而且，对于select来说，有一个FD_SIZE限定了最大的文件描述符集合数量，在Linux里面是1024。当然，这个文件描述符的上限可以被修改，但是一般没有这个必要，因为太多的文件描述符遍历起来过于麻烦。

  2. 对于poll来说，在使用的时候就会方便一点。首先poll传入的只有一个文件描述符集合，然后这个集合里面并不是使用位图的方式来标记信息的，而是一个元素是一个pollfd类型的结构体。这个结构体里面其实有具体的文件描述符（一个），感兴趣的事件events、实际发生的事件revents。然后在事件实际发生的时候，只会修改 revents，所以下次监听事件的时候不需要重置这个文件描述符集合。但是用户取出发生事件就绪的文件描述符、内核标记事件就绪的文件描述符还是需要用遍历的方式来进行，效率比较低。内核、用户态之间的拷贝也继续发生。和select最大的区别是底层使用链表来维护感兴趣的文件描述符，使得维护的数量会比较多，一般为65535。

  3. 对于epoll, 在使用的时候需要用epoll_create来创建一个事件表，然后通过这个事件表使用epoll_ctl来直接管理用户感兴趣的事件。最后返回epoll_event类型的数组。这个事件表是使用红黑树这个数据结构进行管理的，因此，有了这个红黑树，就可以不用像select或者poll一样，把一个数组从用户态拷贝到内核态，而是使用epoll_ctl进行管理就行了。

    在每次调用epoll_wait的时候，不需要重复传入用户监听的文件描述符，省去了大量的文件描述符的复制开销。其次，对于epoll来说，它在文件描述符使用epoll_ctl加入事件表的时候，就设置了改文件描述符在发生就绪事件时的回调函数。在回调函数里面，就绪的文件描述符被放到就绪事件队列中。内核在合适的时机再把这个就绪队列拷贝到用户空间。所以，在用户使用的时候，可以直接拿到就绪的文件描述符和对应发生的事件，而不需要轮询，因此效率比较高。

太长不看版本总结：

  1. epoll不需要每次把一大段标记用户感兴趣的符文描述符传到内核中，减少了拷贝动作带来性能的下降。
  2. epoll返回的数组全部都是就绪的，直接处理就行。select、poll拿到的数组里面夹杂一些没就绪的，浪费时间！

二、3种模型的使用框架

1. select的使用

#include <stdio.h>
#include <sys/time.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/select.h>

int main() {

    //创建socket
    int lfd = socket(PF_INET, SOCK_STREAM, 0);
    struct sockaddr_in saddr;
    saddr.sin_port = htons(9999);
    saddr.sin_family = AF_INET;
    saddr.sin_addr.s_addr = INADDR_ANY;

    //绑定
    bind(lfd, (struct sockaddr*)&saddr, sizeof(saddr));

    //监听
    listen(lfd, 8);

    //创建一个fd_set的集合，存放的是需要检测的文件描述符
    fd_set rdset, tmp;
    //清空标志位
    FD_ZERO(&rdset);
    //添加需要检测的文件描述符
    FD_SET(lfd, &rdset);

    int maxfd = lfd;

    while (1) {
        tmp = rdset;

        int ret = select(maxfd + 1, &tmp, NULL, NULL, NULL);
        if (ret == -1) {
            perror("select");
            exit(-1);
        } else if (ret == 0) {
            continue;;
        } else if (ret > 0) {
            if (FD_ISSET(lfd, &tmp)) {
                // 表示有新的客户端连接进来了
                struct sockaddr_in clientaddr;
                int len = sizeof(clientaddr);
                int cfd = accept(lfd, (struct sockaddr*)&clientaddr, &len);

                //将新的文件描述符添加进集合中
                FD_SET(cfd, &rdset);

                //更新最大文件描述符
                maxfd = maxfd > cfd ? maxfd : cfd;
            }

            for (int i = lfd + 1; i <= maxfd; ++i) {
                if (FD_ISSET(i, &tmp)) {
                    // 说明客户端发来了数据
                    char buf[1024] = {0};
                    int size = read(i, buf, sizeof(buf));
                    if (size == -1) {
                        perror("read");
                        exit(-1);
                    } else if (size == 0) {
                        printf("client close...\n");
                        close(i);
                        FD_CLR(i, &rdset);
                    } else if (size > 0) {
                        printf("recv data: %s\n", buf);
                        write(i, buf, strlen(buf) + 1);
                    }
                }
            }
        }
    }

    close(lfd);
    return 0;
}

2. poll的使用

#include <stdio.h>
#include <sys/time.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <poll.h>

int main() {

    //创建socket
    int lfd = socket(PF_INET, SOCK_STREAM, 0);
    struct sockaddr_in saddr;
    saddr.sin_port = htons(9999);
    saddr.sin_family = AF_INET;
    saddr.sin_addr.s_addr = INADDR_ANY;

    //绑定
    bind(lfd, (struct sockaddr*)&saddr, sizeof(saddr));

    //监听
    listen(lfd, 8);

    //初始化检测的文件描述符数组
    struct pollfd fds[1024];
    for (int i = 0; i < 1024; ++i) {
        fds[i].fd = -1;
        fds[i].events = POLLIN;
    }

    fds[0].fd = lfd;
    int nfds = 0;

    while (1) {
        //调用poll系统函数
        int ret = poll(fds, nfds + 1, -1);// -1表示阻塞
        if (ret == -1) {
            perror("poll");
            exit(-1);
        } else if (ret == 0) {
            continue;;
        } else if (ret > 0) {
            if (fds[0].revents & POLLIN) {
                // 表示有新的客户端连接进来了
                struct sockaddr_in clientaddr;
                int len = sizeof(clientaddr);
                int cfd = accept(lfd, (struct sockaddr*)&clientaddr, &len);

                //将新的文件描述符添加进集合中
                for (int i = 1; i < 1024; ++i) {
                    if (fds[i].fd == -1) {
                        fds[i].fd = cfd;
                        fds[i].events = POLLIN;
                        break;
                    }
                }

                //更新最大文件描述符
                nfds = nfds > cfd ? nfds : cfd;
            }

            for (int i = 1; i <= nfds; ++i) {
                if (fds[i].revents & POLLIN) {
                    // 说明客户端发来了数据
                    char buf[1024] = {0};
                    int size = read(fds[i].fd, buf, sizeof(buf));
                    if (size == -1) {
                        perror("read");
                        exit(-1);
                    } else if (size == 0) {
                        printf("client close...\n");
                        close(fds[i].fd);
                        fds[i].fd = -1;
                    } else if (size > 0) {
                        printf("recv data: %s\n", buf);
                        write(fds[i].fd, buf, strlen(buf) + 1);
                    }
                }
            }
        }
    }

    close(lfd);
    return 0;
}

3.epoll的使用

在epoll中有ET和LT两种不同的模式。

ET模式下，发生了就绪事件，数据需要一次性读完，否则下次不通知你了。而LT模式下，不处理就绪事件，下次依然通知你。

下面是两种模式的不同实现。

3. 1 ET模式

#include <stdio.h>
#include <sys/time.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/epoll.h>
#include <fcntl.h>
#include <errno.h>

int main() {

    //创建socket
    int lfd = socket(PF_INET, SOCK_STREAM, 0);
    struct sockaddr_in saddr;
    saddr.sin_port = htons(9999);
    saddr.sin_family = AF_INET;
    saddr.sin_addr.s_addr = INADDR_ANY;

    //绑定
    bind(lfd, (struct sockaddr*)&saddr, sizeof(saddr));

    //监听
    listen(lfd, 8);

    //创建epoll instance
    int epfd = epoll_create(222);

    //将监听的文件描述符加入到epoll实例中
    struct epoll_event epev;
    epev.events = EPOLLIN;
    epev.data.fd = lfd;
    epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &epev);

    //
    struct epoll_event epevs[1024];
    while (1) {

        int ret = epoll_wait(epfd, epevs, 1024, -1);
        if (ret == -1) {
            perror("epoll");
            exit(-1);
        }

        printf("ret=%d\n", ret);

        for (int i = 0; i < ret; ++i) {

            int curfd = epevs[i].data.fd;

            if (curfd == lfd) {
                //监听的文件描述符有客户端连接
                // 表示有新的客户端连接进来了
                struct sockaddr_in clientaddr;
                int len = sizeof(clientaddr);
                int cfd = accept(lfd, (struct sockaddr*)&clientaddr, &len);

                //设置FD属性非阻塞
                int flag = fcntl(cfd, F_GETFL);
                flag |= O_NONBLOCK;
                fcntl(cfd, F_SETFL, flag);

                epev.events = EPOLLIN | EPOLLET; //设置边沿触发

> 这里是引用

                epev.data.fd = cfd;
                epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &epev);
            } else {
                if (epevs[i].events & EPOLLOUT) {
                    continue;
                }
                //循环读取所有的数据
                char buf[5];
                int len = 0;
                while ( (len = read(curfd, buf, sizeof(buf))) > 0) {
                    //打印数据
                    //printf("client data = %s\n", buf);
                    write(STDOUT_FILENO, buf, len);
                    write(curfd, buf, len);
                }

                if (len == 0) {
                    printf("client close...");
                } else if (len == -1) {
                    if (errno == EAGAIN) {
                        printf("data over...\n");
                    } else {
                        perror("read");
                        exit(-1);
                    }             
                }
            }
        }

    }

    close(lfd);
    close(epfd);

    return 0;
}

3. 2 LT模式

#include <stdio.h>
#include <sys/time.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/epoll.h>

int main() {

    //创建socket
    int lfd = socket(PF_INET, SOCK_STREAM, 0);
    struct sockaddr_in saddr;
    saddr.sin_port = htons(9999);
    saddr.sin_family = AF_INET;
    saddr.sin_addr.s_addr = INADDR_ANY;

    //绑定
    bind(lfd, (struct sockaddr*)&saddr, sizeof(saddr));

    //监听
    listen(lfd, 8);

    //创建epoll instance
    int epfd = epoll_create(222);

    //将监听的文件描述符加入到epoll实例中
    struct epoll_event epev;
    epev.events = EPOLLIN;
    epev.data.fd = lfd;
    epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &epev);

    //
    struct epoll_event epevs[1024];
    while (1) {

        int ret = epoll_wait(epfd, epevs, 1024, -1);
        if (ret == -1) {
            perror("epoll");
            exit(-1);
        }

        printf("ret=%d\n", ret);
        printf("ret=%d\n", ret);

        for (int i = 0; i < ret; ++i) {

            int curfd = epevs[i].data.fd;

            if (curfd == lfd) {
                //监听的文件描述符有客户端连接
                // 表示有新的客户端连接进来了
                struct sockaddr_in clientaddr;
                int len = sizeof(clientaddr);
                int cfd = accept(lfd, (struct sockaddr*)&clientaddr, &len);

                epev.events = EPOLLIN;
                epev.data.fd = cfd;
                epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &epev);
            } else {
                // 有数据到达 读数据
                char buf[5] = {0};
                int size = read(curfd, buf, sizeof(buf));
                if (size == -1) {
                    perror("read");
                    exit(-1);
                } else if (size == 0) {
                    printf("client close...\n");
                    epoll_ctl(epfd, EPOLL_CTL_DEL, curfd, NULL);
                    close(curfd);
                } else if (size > 0) {
                    printf("recv data: %s\n", buf);
                    write(curfd, buf, strlen(buf) + 1);
                }
            }
        }

    }

    close(lfd);
    close(epfd);

    return 0;
}

4. 可以和以上多种I/O复用通信的客户端实现

#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

int main() {

    // 1.创建套接字
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    if (fd == - 1) {
        perror("socket");
        exit(-1);
    }

    //2. 连接服务器端
    struct sockaddr_in severaddr;
    severaddr.sin_family = AF_INET;
    severaddr.sin_port = htons(9999);
    // 注意改为自己的IP
    inet_pton(AF_INET, "192.168.133.138", &severaddr.sin_addr.s_addr);
    int ret = connect(fd, (struct sockaddr*)&severaddr, sizeof(severaddr));
    if (ret == - 1) {
        perror("connect");
        exit(-1);
    }
    
    // 与服务器端进行通信
    // 读取数据

    int i = 0;
    while (1) {
        char revBuf[1024] = {0};
        fgets(revBuf, sizeof(revBuf), stdin);

        // sprintf(revBuf, "data: %d\n", i++);
        write(fd, revBuf, strlen(revBuf) + 1);

        int len = read(fd, revBuf, sizeof(revBuf));
        if (len == - 1) {
            perror("read");
            exit(0);
        } else if (len > 0) {
            printf("read buf = %s\n", revBuf);
        } else if (len == 0) {
            // 表示客户端断开连接
            printf("server close\n");
            break;
        }
    }

    //关闭连接
    close(fd);

    return 0;
}
zsiming
关注
专栏目录
select、poll和epoll的对比
baidu_38737437的博客
07-14 235
select、poll、epoll都是linux下的I/O复用系统调用。它们都能监听多个文件描述符，等待由timeout参数指定的超时时间，直到一个或者多个文件描述符上有事件发生时返回，返回值就是就绪的文件描述符的数量。返回0表示没有事件发生。下面来讲讲三个函数的不同之处 一、事件集 select: select的参数类型没有将文件描述符（fd）和事件进行一个绑定，因此在传参部分需要三个参数分别对应可读、可写、异常事件 缺点： 只能处理可读、可写以及异常等事件，所以可读、可写以及异常等事件不能处
epoll比select和poll高效的原因
Move_now的博客
05-12 2415
我们通过比较select、poll和epoll处理I/O的过程来剖析其中的原因：1. 用户态将文件描述符传入内核的方式：select：创建3个文件描述符集并拷贝到内核中,分别监听读、写、异常动作。这里受到单个进程可以打开的fd数量限制,默认是1024。 poll：将传入的struct pollfd结构体数组拷贝到内核中进行监听。 epoll：执行epoll_create会在内核的高速
epoll为什么这么快
Gothic的专栏
11-14 1145
  epoll是多路复用IO(I/O Multiplexing)中的一种方式,但是仅用于linux2.6以上内核,在开始讨论这个问题之前,先来解释一下为什么需要多路复用IO.以一个生活中的例子来解释.假设你在大学中读书,要等待一个朋友来访,而这个朋友只知道你在A号楼,但是不知道你具体住在哪里,于是你们约好了在A号楼门口见面.如果你使用的阻塞IO模型来处理这个问题,那么你就只能一直
epoll基本原理二： Epoll 比 Select 高效的原因
Peter的博客
01-04 511
从事服务端开发，少不了要接触网络编程。Epoll 作为 Linux 下高性能网络服务器的必备技术至关重要，Nginx、Redis、Skynet 和大部分游戏服务器都使用到这一多路复用技术。 Epoll 很重要，但是 Epoll 与 Select 的区别是什么呢？Epoll 高效的原因是什么？ 网上虽然也有不少讲解 Epoll 的文章，但要么是过于浅显，或者陷入源码解析，很少能有通俗易懂的...
select,poll和epoll对比分析
考拉先生的专栏
05-23 488
    最近研究python IO多路复用，发现很多案例都是基于selelct，而很少谈到poll和epoll。尽管知道晚出现的epoll的处理机制更优，但却不明白其中道理。于是将互联网上资料整理总结了一下。    elect/poll/epoll都是IO多路复用机制，可以同时监控多个描述符，当某个描述符就绪(读或写就绪)，则立刻通知相应程序进行读或写操作。本质上select/poll/epoll...
彻底搞懂 select/poll/epoll，就这篇了！
Linuxhus的博客
06-18 6005
之前已经把网络 I/O 相关要点都盘了，还剩 select/poll/epoll 这几个区别没说，这篇就来搞搞它们，并且是从完全理解原理的角度来区分它们。本来是要上源码的，但是感觉没啥必要，身为应用开发我觉得理解原理就行了，源码反正看了就忘了，理解才是最重要！所以我就尽量避免代码且用大白话来盘一盘这三个玩意。话不多说，发车。首先，我们知道 select/poll/epoll 是用来实现多路复用的，即一个线程利用它们即可 hold 住多个 socket。按照这个思路，线程不可被任何一个被管理的 Socket
select、poll、epoll的底层原理剖析
最新发布
lt_xiaodou的博客
10-05 964
/ 定义位于/sys/select.h文件中复制代码nfds ：表示 FDS 中有效的 FD 数量，全部文件描述符的最大值 +1。readfds ：表示需要监控读事件发生的文件描述符集合。writefds ：表示需要监控写事件发生的文件描述符集合。exceptfds ：表示需要监控异常/错误发生的文件描述符集合。timeout ：表示 select 在没有事件触发的情况下，会阻塞的时间。
select和epoll实现多路复用.zip
05-20
实验报告`epoll和select实现多路复用.docx`应该详细记录了实验的步骤、代码实现、测试过程以及分析结果。通过阅读报告，你可以深入理解这两种多路复用方法在实际应用中的差异，以及它们对系统资源的利用情况。 总结...
彻底搞懂 select/poll/epoll，就这篇了
m0_71777195的博客
06-14 1355
之前已经把网络 I/O 相关要点都盘了，还剩 select/poll/epoll 这几个区别没说，这篇就来搞搞它们，并且是从完全理解原理的角度来区分它们。本来是要上源码的，但是感觉没啥必要，身为应用开发者我觉得理解原理就行了，源码反正看了就忘了，理解才是最重要！所以我就尽量避免代码且用大白话来盘一盘这三个玩意。话不多说，发车。首先，我们知道 select/poll/epoll 是用来实现多路复用的，即一个线程利用它们即可 hold 诸多个 socket。按照这个思路，线程不可能被任何一个被管理的 Socke
epoll对poll(select)的改进
weixin_30472035的博客
07-30 93
select的几大缺点： 每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多时会很大； 每次调用select，内核需要遍历传递进来的所有fd(判断检测文件是否可用)。有时只有部分连接是“活跃”的，但是select/poll每次调用都会线性扫描全部的集合； select支持的文件描述符数量太小了，默认是1024；可以选择修改这个宏然后重新编译内核...
epoll原理_NIO模型，select/epoll的区别，多路复用的原理 软件开发其他 红黑联盟...
weixin_39742471的博客
11-26 156
　select，poll，epoll都是IO多路复用的机制。I/O多路复用就通过一种机制，可以监视多个描述符，一旦某个描述符就绪(一般是读就绪或者写就绪)，能够通知程序进行相应的读写操作。但select，poll，epoll本质上都是同步I/O，因为他们都需要在读写事件就绪后自己负责进行读写，也就是说这个读写过程是阻塞的，而异步I/O则无需自己负责进行读写，异步I/O的实...
为什么epoll 比 select 高效
jinchengzhou的专栏
06-12 2232
1.epoll epool_waita函数，函数返回值nfds<=maxevents nfds = epoll_wait(kdpfd, events, maxevents, -1); 其中kdpfd为用epoll_create创建之后的句柄，events是一个epoll_event*的指针，当epoll_wait这个函数操作成功之后，epoll_events里面将储存所有的读写事件。 ma
epoll到底为什么比select高效
sweet_sauce的博客
03-01 909
作者：静海听风 链接：https://www.zhihu.com/question/20122137/answer/146866418 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 第一部分：select和epoll的任务 关键词：应用程序 文件句柄 用户态 内核态 监控者 要比较epoll相比较select高效在什么地方，就需要比较二者做相同事情的方...
select和epoll对比
点星之人
04-15 1411
select和epoll对比 什么是epoll模型？ epoll是Linux内核为处理大批量句柄而作了改进的poll， 是Linux下多路复用IO接口select/poll的增强版本， 它能显著减少程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率。 因为它会复用文件描述符集合来传递结果， 而不用迫使开发者每次等待事件之前都必须重新准备要被侦听的文件
为什么epoll比select效率更高(Why is epoll faster than select)?
caiyiii的专栏
10-20 453
Why is epoll faster than select? A typical server might be dealing with, say, 200 connections. It will service every connection that needs to have data written or read and then it will need to wait u...
epoll比select高效的原因
zhjs_abc的博客
09-18 268
select每次调用select()时都要传入fds数组，而epoll在内核维护了一个等待队列，每次调用epoll_wait()时不需要传入等待队列进去，只在执行epoll_ctl()时才更新等待队列。降低了内核与用户层的数据迁移； select()返回后每次都要遍历所有被监视的文件描述符，而epoll_wait()返回时已经将有事件发生的文件描述符放到了一个数组中，所以用户层只需要遍历有事件发生的文件描述符即可，大大降低了遍历范围； select是将当前进程添加到每个被监视的socket的等待队列里面，.
epoll为何比select和poll快----select poll epoll之间的对比
城南花已开的博客
03-10 378
select： int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout); 通过位图的数据结构来设置监听的文件描述符，对应位为1表示该文件描述符需要监听。受fd_set的限制最多只能监听1024个文件描述符...
Linux IO复用：select、poll与epoll全面对比分析
在Linux系统中，为了实现高效的I/O多路复用，提供了三种主要的机制：select、poll和epoll。这些机制允许程序同时监控多个文件描述符，等待数据就绪后再进行处理。下面将详细探讨这三种方法的异同。 1. select函数 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值