I/O多路转接之epoll

最新推荐文章于 2024-07-13 09:18:48 发布
最新推荐文章于 2024-07-13 09:18:48 发布
阅读量274 收藏
点赞数
分类专栏： IO 文章标签： epoll IO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/han8040laixin/article/details/81214986
版权

按照man手册的说法：是为了处理大批量句柄而作了改进的poll。
这句话对我而言，说和不说没什么区别，太抽象了，所以要弄清楚什么是epoll，还是要从底层剖析！

epoll的三个相关系统调用

一：epoll_create：创建一个epoll模型（也是文件）
这里写图片描述

参数解释：
size：指定生成文件描述符的最大范围。

返回值解释：
返回一个文件描述符，该fd标识创建的epoll模型。

二：epoll_ctl：向epoll模型添加/修改/删除对应文件描述符的对应事件
这里写图片描述

参数解释：
①epfd:epoll_create的返回值。
②op：表示处理的方式，有添加，修改或删除，用三个宏表示：
这里写图片描述
③fd：要监听的对应文件描述符
④event：要关心什么事件
struct epoll_event的结构：
这里写图片描述
至于events，我还是只介绍两个：
EPOLLIN：对应fd可读
EPOLLOUT：对应fd可写

返回值解释
成功返回0，失败返回-1。

三： epoll_wait
这里写图片描述
参数解释：
①epfd:epoll_create的返回值。
②events：是一个数组，为输出型，epoll会将发生的事件复制到该数组，所以不能为空。
③maxevents：poll_wait可以处理的连接事件的最大限度值
④timeout：和poll一样。
这里写图片描述

要理解epoll，就要知道epoll模型到底是什么！
这里写图片描述

调用epoll_create,创建一个epoll模型，要做三件事：
1.在操作系统底层构建回调机制；
2.在操作系统底层构建红黑树（而监听的文件描述符正好作为红黑树的键值）；
3.在操作系统底层构建就绪队列；

调用epoll_ctl，就是对红黑树的节点（对应监听的文件描述符）进行添加/修改/删除操作。

调用epoll_wait,当事件就绪时：
把对应节点拷贝一份至就绪队列，而epoll看的就是就绪队列，所以为O(1)的时间复杂度。

epoll有两种工作模式：LT（水平触发）和ET（边缘触发）

现在假设一个场景：
已经把一个socke的读事件t添加到epoll模型；
此时socket的对端写入了10kb的数据；
调用epoll_wait，会返回，说明已经就绪；
然后调用read读取了5kb数据；
继续调用epoll_wait

LT工作模式：

epoll默认为LT工作模式，在该模式下，当socket上事件就绪，可以不立即处理或者只处理一部分；
比如上面的场景，我只读了5kb的数据，缓冲区还剩5kb，当我再次调用epoll_wait，它还是会返回，告诉我socket的读事件就绪；
直到缓冲区的所有数据全部处理完，epoll_wait才不会返回；
LT支持非阻塞读写与阻塞读写。

举个例子：张三是个快递派送员，有一天他给我派送快递，打电话叫我下楼来拿，但是我当时很忙，叫他在楼下等一会，张三就在楼下等；过了一会我下楼了，但是快递太多，我一次拿不完，我就给张三说，我先拿一部分上楼，你在这等着，我待会再拿剩下的，张三就接着等，直到我拿完快递。

LT模式下的epoll服务器

int main(int argc,char* argv[])
{
    //建立监听套接字
    if(argc != 3){
        printf("./server [ip] [port]\n");
        return 1;
    }

    int listen_sock = socket(AF_INET,SOCK_STREAM,0);
    if(listen_sock < 0){
        perror("socket");
        return 2;
    }

    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_addr.s_addr = inet_addr(argv[1]);
    local.sin_port = htons(atoi(argv[2]));

    if(bind(listen_sock,(struct sockaddr*)&local,sizeof(local)) < 0){
        perror("bind");
        return 3;
    }

    if(listen(listen_sock,5) < 0){
        perror("listen");
        return 4;
    }

    //创建epoll模型
    int epoll_fd = epoll_create(100);
    if(epoll_fd < 0){
        perror("epoll_create");
        return 5;
    }

    //listen_sock的读事件
    struct epoll_event event;
    event.events = EPOLLIN;
    event.data.fd = listen_sock;

    //将listen_sock的读事件添加进epoll模型
    if(epoll_ctl(epoll_fd,EPOLL_CTL_ADD,listen_sock,&event) < 0){
        perror("epoll_ctl");
        return 6;
    }

    while(1){
        struct epoll_event events[10];//作epoll_wait的参数，输出型
        int size = epoll_wait(epoll_fd,events,sizeof(events)/sizeof(events[0]),-1);//阻塞式等待
        if(size == 0){
            printf("超时！");
            continue;
        }
        if(size < 0){
            perror("epoll_wait");
            continue;
        }
        //else size > 0,有事件就绪
        int i = 0;
        for( ; i<size; i++){
            if(!(events[i].events & EPOLLIN))//必须是读就绪
                continue;

            if(events[i].data.fd == listen_sock){//listen_sock就绪，该建立连接了
                struct sockaddr_in addr;
                socklen_t len = sizeof(addr);
                int new_sock = accept(listen_sock,(struct sockaddr*)&addr,&len);
                if(new_sock < 0){
                    perror("new_sock");
                    continue;
                }

                //有了新的fd，所以将new_sock的读事件加入模型
                struct epoll_event ev;
                ev.data.fd = new_sock;
                ev.events = EPOLLIN;
                if(epoll_ctl(epoll_fd,EPOLL_CTL_ADD,new_sock,&ev) < 0){
                    perror("epoll_ctl");
                    continue;
                }
            }
            else{//普通sock就绪，开始读
                char buf[1024];
                ssize_t s = read(events[i].data.fd,buf,sizeof(buf)-1);
                if(s < 0){
                    perror("read");
                    continue;
                }
                printf("client >%s\n",buf);
            }
        }
    }
    return 0;
}

ET工作模式
在设置epoll_ctl的第二个参数时的事件时，加上EPOLLET标志，epoll变为ET工作模式：
这里写图片描述

接着拿上面的场景举例，ET模式下，虽然只读了5kb的数据，缓冲区还有5kb数据没有处理，但第二次调用epoll_wait，就不会再返回了；
换句话说，ET模式下，socket事件就绪，只有一次处理机会，必须马上处理；
所以ET的效率比LT更高；
ET只支持非阻塞的读写。

举个例子，李四也是个快递派送员，他也给我派送快递，打电话叫我下楼来拿，我还是忙啊，就叫他等一会；忙完我下楼了，快递还是太多一次拿不完，我给李四说：我先拿一部分上楼，你在这等着，我待会再拿剩下的，于是我拿着一部分快递上楼了，但是李四不管我那么多，直接就走了。
所以如果是李四这种派送员，我必须要一次拿完快递！

ET为什么只支持非阻塞读写？
ET模式下数据就绪只会返回一次，所以当数据就绪时，就要一直read，直到读完或出错（必须一次性拿完快递）。
如果当前fd是阻塞，当读完缓冲区数据，如果对端不关闭写，那么read函数会一直阻塞，影响后续逻辑。
至于如何将文件描述符设为非阻塞，以及非阻塞情况下如何读的问题，我在另一篇文章《非阻塞IO》中有详细说明，附链接：
https://blog.csdn.net/han8040laixin/article/details/81232464

ET模式下的epoll服务器

void SetNonBlock(int sock)//把该文件描述符设为非阻塞
{
    int f1 = fcntl(sock,F_GETFD);//获取sock
    if(f1 < 0){
        perror("fcntl");
        return;
    }
    fcntl(f1,F_SETFL,f1|O_NONBLOCK);//将当前属性按位与O_NONBLOCK,其实就是把对应为设为1，使其变为非阻塞
}

int main(int argc,char* argv[])
{
    if(argc != 3){
        printf("./server [ip] [port]\n");
        return 1;
    }

    //建立监听套接字
    int listen_sock = socket(AF_INET,SOCK_STREAM,0);
    if(listen_sock < 0){
        perror("socket");
        return 2;
    }

    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_addr.s_addr = inet_addr(argv[1]);
    local.sin_port = htons(atoi(argv[2]));

    if(bind(listen_sock,(struct sockaddr*)&local,sizeof(local)) < 0){
        perror("bind");
        return 3;
    }

    if(listen(listen_sock,5) < 0){
        perror("listen");
        return 4;
    }

    //ET模式下只支持非阻塞读写，将listen_sock设为非阻塞
    SetNonBlock(listen_sock);

    //建立epoll模型
    int epoll_fd = epoll_create(100);
    if(epoll_fd < 0){
        perror("epoll");
        return 5;
    }

    //listen_sock的读事件
    struct epoll_event event;
    event.events = EPOLLIN|EPOLLET;//把工作模式变为ET模式
    event.data.fd = listen_sock;
    //将listen_sock（非阻塞）的读事件添加进ET模式下的epoll模型
    if(epoll_ctl(epoll_fd,EPOLL_CTL_ADD,listen_sock,&event) < 0){
        perror("epoll_ctl");
        return 6;
    }

    while(1){
        struct epoll_event events[15];//输出型
        int size = epoll_wait(epoll_fd,events,sizeof(events)/sizeof(events[0]),-1);//非阻塞等待
        if(size < 0){
            printf("出错!\n");
            continue;
        }
        if(size == 0){
            printf("超时!\n");
                continue;
        }
        //else size > 0 有事件就绪
        int i = 0;
        for( ; i<size; i++ ){
            if(!(events[i].events & EPOLLIN))//必须是读事件
                continue;

            if(events[i].data.fd == listen_sock){//listen_sock就绪，可以建立连接了
                struct sockaddr_in addr;
                socklen_t len = sizeof(addr);
                int new_sock = accept(listen_sock,(struct sockaddr*)&addr,&len);
                if(new_sock < 0){
                    perror("accept");
                    continue;
                }
                SetNonBlock(new_sock);//设为非阻塞
                //new_sock的读事件
                struct epoll_event ev;
                ev.events = EPOLLIN|EPOLLET;//ET
                ev.data.fd = new_sock;
                if(epoll_ctl(epoll_fd,EPOLL_CTL_ADD,new_sock,&ev) < 0){
                    perror("epoll_ctl");
                    continue;
                }
            }
            else{//普通sock就绪，可以读了，但在ET模式下要一次读完
                //非阻塞调用：\
                  1.不会阻塞式等待\
                  2.条件不满足时直接以出错形式返回，错误码errno被设为EAGAIN(11号)
                  char buf[1024];
                  ssize_t total_size = 0;
                  while(1){
                      ssize_t s = read(events[i].data.fd,buf+total_size,1024);
                      total_size = total_size + s;
                      if(s < 1024 || errno == EAGAIN)
                          break;
                  }
                  buf[total_size] = '\0';
                  printf("client> %s\n",buf);
            }
        }
    }

客户端和select，poll都一样。

epoll的优缺点：
优点：
1.文件描述符无上限，操作系统使用红黑树管理fd。
2.维护就绪队列：当fd就绪，操作系统会把它从红黑树拷贝一份放到就绪队列，这样使用epoll_wait获取就绪fd时，只用看就绪队列，它是O(1)的时间复杂度。
3.事件就绪通知机制：一旦被监听的fd就绪，会有回调机制迅速激活该fd，这样即使fd的数量增加，也不会影响判断就绪的性能。
epoll并没有所谓的内存映射机制，操作系统不相信任何人！而且epoll_wait里传了缓冲区，如果都内存映射了，根本不需要缓冲区，所以不存在内存映射机制！
缺点：
epoll的高性能是有使用场景的，如果在不合适的场景下使用epoll，会适得其反。
epoll适合多连接且只有一部分连接比较活跃的场景，如果只是少数几个连接，调用epoll显然太重了。

_来信
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
I/O多路转接之poll
My Coding Life
07-09 636
ForeWord 本文介绍了实现I/O多路转接模型的poll接口。 Key Point： poll的接口函数介绍 代码实例：用poll监控终端输入输出 ~tips：全文阅读需5min~poll 1.接口函数 linux系统提供了poll来实现IO多路复用模型，下面是其接口函数及参数解释：timeout是一个定时器，单位是ms，不同的值有不同的含义，如下表： timeo
I/O多路转接
weixin_54792212的博客
08-08 295
1
多路转接(IO复用)接口介绍
m0_51723227的博客
11-20 6184
参数nfds,整型,意义表示select所需要轮询的fd中的最大值加一.例如select需要轮询的fd有,那么;至于为什么加一,理由很简单,其实就是循环的一个遍历界限,比如我要遍历5次,那么循环就是for(int i = 0;i
I/O多路转接 —— select、poll、epoll
M的博客
12-22 1353
select、poll和epoll详解，通俗易懂
LinuxI/O多路转接
hbbfvv1h的博客
04-14 1903
基础知识 阻塞与非阻塞 阻塞调用是指调用结果返回之前，当前线程会被挂起. 调用线程只有在得到结果之后才会返回 非阻塞调用指在不能立刻得到结果之前，该调用不会阻塞当前线程 同步通信 vs 异步通信 同步：调用者发出调用时，没有得到结果不会返回，阻塞等待，调用者主动等待该调用结果 异步：与同步相反，发出调用后立即返回，调用内的工作由别人完成，等待被调用者的通知，直接使用，自己并不参与 非阻塞IO 一个文件描述符, 默认都是阻塞IO int fcntl(int fd, int cmd, … /* arg */
I/O多路转接之select
10-24
在本例中，我们将聚焦于"I/O多路转接之select"，这是一种在Unix-like系统中广泛使用的机制。"select"函数是实现这一功能的核心，它允许程序员在一个进程内同时处理多个输入/输出流，提高了程序的效率和响应性。 ...
Linux I/O多路复用详解及实例
09-15
在Linux中，I/O多路复用主要有三种实现方式：`select`、`poll`和`epoll`。这些机制都用于解决传统阻塞I/O模型中，进程在等待I/O操作完成时被挂起的问题。 阻塞I/O是最常见的I/O模型，当进程尝试从一个未准备好数据...
IO多路复用之epoll全面总结(必看篇)
09-15
在Linux系统中，epoll是针对IO多路复用的一种高效实现，尤其适用于大规模并发连接的场景。以下是关于epoll的详细总结： 1. **基本概念** - **epoll** 是在Linux 2.6内核引入的，是对早期的`select`和`poll`函数的...
Linux IO多路复用之epoll网络编程
09-15
在Linux系统中，IO多路复用是一种高效的网络编程技术，它允许多个网络连接在同一时间进行处理，而不...结合非阻塞I/O，`epoll`能极大地提升服务器的并发处理能力，从而在大型分布式系统和高性能服务中得到广泛应用。
C++中I/O模型之select模型实例
09-04
其中，`select`模型是一种经典的多路复用I/O模型，它允许程序同时监控多个文件描述符（如套接字）的状态，以便于高效地处理并发的网络事件。下面将详细讲解`select`模型的工作原理以及如何在C++中使用它。 首先，`...
Epoll的本质（内部实现原理）
k916631305的博客
11-06 1583
转自：https://zhuanlan.zhihu.com/p/63179839 作者：罗培羽 从事服务端开发，少不了要接触网络编程。epoll作为linux下高性能网络服务器的必备技术至关重要，nginx、redis、skynet和大部分游戏服务器都使用到这一多路复用技术。 因为epoll的重要性，不少游戏公司（如某某九九）在招聘服务端同学时，可能会问及epoll相关的问题。比如epoll和select的区别是什么？epoll高效率的原因是什么？如果只靠背诵，显然不能算上深刻的理解。 网上虽.
细谈select函数（C语言）
ai1053154867的博客
09-24 2126
Select在Socket编程中还是比较重要的，可是对于初学Socket的人来说都不太爱用Select写程序，他们只是习惯写诸如connect、accept、recv或recvfrom这样的阻塞程序（所谓阻塞方式block，顾名思义，就是进程或是线程执行到这些函数时必须等待某个事件的发生，如果事件没有发生，进程或线程就被阻塞，函数不能立即返回）。可是使用Select就可以完成非阻塞（所谓...
epoll下ET模式为何一定要用要用非阻塞的模式~
绝迹·危言的专栏
02-26 2033
在ET模式中，对于读写请求，阻塞和非阻塞都可以解决问题。但是，对于accept之类的连接请求就不行了。 根本原因我认为是连接是涉及网络双方的交互，比如三次的握手。这样即使epoll已经等待连接事件，但是不能保证能 接收到新连接。而recv等数据已经到本机的内核缓冲区了，剩下的都是本机数据的读取操作，是必然可以解决的。 终上所述，影响网络双方的操作都该注意是否使用非阻塞模式，在设置相应的套接字
epoll的ET模式为什么一定要使用非阻塞IO
zhwenx3的博客
02-26 3167
ET模式下每次write或read需要循环write或read直到返回EAGAIN错误。以读操作为例，这是因为ET模式只在socket描述符状态发生变化时才触发事件，如果不一次把socket内核缓冲区的数据读完，会导致socket内核缓冲区中即使还有一部分数据，该socket的可读事件也不会被触发 根据上面的讨论，若ET模式下使用阻塞IO，则程序一定会阻塞在最后一次write或read操作，因此...
Linux——多路IO
最新发布
m0_71703182的博客
07-13 262
④ select返回-1表示错误，返回0表示超时时间到没有监听到的事件发生，返回正数表示监听到的所有事件数（包括可读，可写，异常），通常在处理事件时 会利用这个返回值来提高效率，避免不必要的事件触发检查。① readfds等是指针结果参数，会被函数修改，所以一般会另外定义一个allread_fdset，保持全部要监听读的句柄，将它的拷贝传递给select函数，返回可读的句柄集合，类型fdset支持赋值运算符=；这样，进程就可以在需要时处理IO事件，而无需轮询或阻塞等待。
画出I/O多路复用模型的过程
05-07
I/O多路复用是一种高效的I/O处理方式，它可以同时监听多个I/O事件，通过一个线程来处理这些事件，提高系统的并发性能。下面是画出I/O多路复用模型的过程： 1. 创建一个文件描述符集合，用于存放需要监听的I/O事件。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值