IO多路复用--epoll

最新推荐文章于 2023-05-12 20:25:39 发布
最新推荐文章于 2023-05-12 20:25:39 发布
阅读量443 收藏 1
点赞数 2
分类专栏： Linux网络编程 文章标签： epoll
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jocker_D/article/details/86565877
版权
epoll

首先解释下为什么会有epoll，前面我们看了poll和select因为监听事件的增加会导致效率下降比较严重此时当处理大量IO时间时就需要一种效率比较高的处理模式，而epoll就是为了处理大批量句柄设计的IO多路复用模型。另外epoll适用于同一时间大量连接少量活跃的情况，其底层采用红黑树管理监听的描述符，双向链表管理活跃的描述符在红黑树中的指针，如果同一时间活跃的描述符特别多时会导致操作频繁。

epoll接口

int epoll_create(int size); //自从linux2.6.8之后,size参数是被忽略的,用完之后, 必须调用close()关闭.
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);

其中epoll_create是建立一个epoll对象(在epoll文件系统中为这个句柄对象分配资源)，Linux下一切皆文件
epoll_ctl用于监听事件的添加删除和修改，通过op参数来控制.epfd为epoll_create返回的描述符， event是监听的事件，
op的取值如下：
EPOLL_CTL_ADD :注册新的fd到epfd中;
EPOLL_CTL_MOD :修改已经注册的fd的监听事件;
EPOLL_CTL_DEL :从epfd中删除一个fd
epoll_event结构：
struct epoll_event {
__u32 events;
__u64 data;
} EPOLL_PACKED;
events可以是以下几个宏的集合:
EPOLLIN : 表示对应的文件描述符可以读 (包括对端SOCKET正常关闭);
EPOLLOUT : 表示对应的文件描述符可以写;
EPOLLPRI : 表示对应的文件描述符有紧急的数据可读
EPOLLERR : 表示对应的文件描述符发生错误;
EPOLLHUP : 表示对应的文件描述符被挂断;
EPOLLET : 将EPOLL设为边缘触发(Edge Triggered)模式, 这是相对于水平触发(Level Triggered)来说的.
EPOLLONESHOT:只监听一次事件, 当监听完这次事件之后, 如果还需要继续监听这个socket的话, 需要再次把这个socket加入到EPOLL队列里。
epoll_wait用于接受监听到的事件, 参数timeout是超时时间 (毫秒,0会立立即返回,-1是永久阻塞)
关于水平触发和边缘触发，水平触发指的是的当变成一个状态后会一直触发知道状态改变，边缘触发是状态改变时触发，即在遇到到感兴趣事件后只触发一次。如客户端和服务器建立长连接，在边缘触发模式下，客户端发一次数据只会触发一次，水平触发模式下，如果缓存区有数据会一直触发。

客户端

#include <iostream>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>

#define ERROR(message)\
    do \
    {    \
        perror(message); \
        exit(EXIT_FAILURE); \
    }while(0)

int main(int argc, char * argv[])
{
    int sock_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if(sock_fd < 0)
        ERROR("socket error");
    
    struct sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(atoi(argv[2]));
    server_addr.sin_addr.s_addr = inet_addr(argv[1]);
    
    int ret = connect(sock_fd, (struct sockaddr *)&server_addr, sizeof(server_addr));
    if(ret < 0)
        ERROR("connect error");

    for(;;)
    {
        char buff[1024] = { 0 };
        
        std::cin >> buff;
        
        size_t size = write(sock_fd, buff, strlen(buff));
        memset(buff, 0, 1024);
        if(size < 0)
            ERROR("write error");

        size = read(sock_fd, buff, sizeof(buff) - 1);
        if(size < 0)
            ERROR("read error");
        else if(size == 0)
        {
            std::cout << "对方关闭了连接"<<std::endl;
            break;
        }        
        
        std::cout << "server: " << buff << std::endl;
        memset(buff, 0, 1024);
    }
    return 0;
}

LT(水平触发服务器)

#include <iostream>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/epoll.h>
#include <errno.h>
#include <string.h>
#include <string>

#define ERROR(message) \
    do  \
    {   \
        perror(message); \
        exit(EXIT_FAILURE); \
    }while(0)

void ProcessConnect(int listen_fd, int epoll_fd);
void ProcessRequest(int client_fd, int epoll_fd);

int main()
{
    int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    if(listen_fd < 0)
        ERROR("socket error");

    struct sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(9000);
    server_addr.sin_addr.s_addr = INADDR_ANY;

    int opt_ = 1;
    setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &opt_, sizeof(opt_));

    if(bind(listen_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0)
        ERROR("bind error");

    if(listen(listen_fd, 5) < 0)
        ERROR("listen error");

    int epoll_fd = epoll_create(10); //在epoll文件系统中添加
    if(epoll_fd < 0)
        ERROR("epoll_create error");

    struct epoll_event event;
    event.events = EPOLLIN;
    event.data.fd = listen_fd;
    if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listen_fd, &event))
        ERROR("epoll_ctl add error");

    for(;;)
    {
        struct epoll_event events[10];
        for(auto & e :events)
        {
            e.events = 0;
        }
        int size = epoll_wait(epoll_fd, events, sizeof(events)/sizeof(events[0]), -1);
        if(size < 0){
            perror("epoll_wait");
            continue;
        }
        else if(size == 0){
            std::cout << "epoll timeout" << std::endl;
            continue;
        } 
        
        //到此表示有事件触发
        for(int i = 0; i < 10; ++i)
        {
            if(!events[i].events){
                continue;
            }

            if(events[i].data.fd == listen_fd){
                std::cout << "client connect" <<std::endl;
                ProcessConnect(listen_fd, epoll_fd);
            } 
            else{ 
                ProcessRequest(events[i].data.fd, epoll_fd);
            }
        }
    }
    return 0;
}

void ProcessConnect(int listen_fd, int epoll_fd)
{
    struct sockaddr_in client_addr;
    socklen_t socklen = sizeof(client_addr);
    int client_fd = accept(listen_fd, (struct sockaddr *)&client_addr, &socklen); 
    if(client_fd < 0)
        ERROR("accept error");

    struct epoll_event event;
    event.events = EPOLLIN;
    event.data.fd = client_fd;
    
    if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &event))
        ERROR("accept error");
}
void ProcessRequest(int client_fd, int epoll_fd)
{
    char buff[1024] = { 0 };
    size_t size = read(client_fd, buff, 1023);
    
    if(size < 0){
        perror("read error");
        return;
    }
    if(size == 0){
        close(client_fd);
        epoll_ctl(epoll_fd, EPOLL_CTL_DEL, client_fd, NULL);
        return;
    }
    
    std::cout << "client: " << buff << std::endl;
    memset(buff, 0, 1024);
    write(client_fd, "receive", 7);
}

ET(边缘触发)

#include <iostream>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/epoll.h>
#include <errno.h>
#include <string.h>
#include <string>
#include <fcntl.h>
#include <stdlib.h>


#define ERROR(message) \
    do  \
    {   \
        perror(message); \
        exit(EXIT_FAILURE); \
    }while(0)

void ProcessConnect(int listen_fd, int epoll_fd);
void ProcessRequest(int client_fd, int epoll_fd);

int main()
{
    int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    if(listen_fd < 0)
        ERROR("socket error");

    struct sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(9000);
    server_addr.sin_addr.s_addr = INADDR_ANY;

    int opt_ = 1;
    setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &opt_, sizeof(opt_));

    if(bind(listen_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0)
        ERROR("bind error");

    if(listen(listen_fd, 5) < 0)
        ERROR("listen error");

    int epoll_fd = epoll_create(10); //在epoll文件系统中添加
    if(epoll_fd < 0)
        ERROR("epoll_create error");

    struct epoll_event event;
    event.events = EPOLLIN;
    event.data.fd = listen_fd;
    if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listen_fd, &event))
        ERROR("epoll_ctl add error");

    for(;;)
    {
        struct epoll_event events[10];
        for(auto & e :events)
        {
            e.events = 0;
        }
        int size = epoll_wait(epoll_fd, events, sizeof(events)/sizeof(events[0]), -1);
        if(size < 0){
            perror("epoll_wait");
            continue;
        }
        else if(size == 0){
            std::cout << "epoll timeout" << std::endl;
            continue;
        } 
        
        //到此表示有事件触发
        for(int i = 0; i < 10; ++i)
        {
            if(!events[i].events){
                continue;
            }

            if(events[i].data.fd == listen_fd){
                std::cout << "client connect" <<std::endl;
                ProcessConnect(listen_fd, epoll_fd);
            } 
            else{ 
                ProcessRequest(events[i].data.fd, epoll_fd);
            }
        }
    }
    return 0;
}

static void SetNoBlock(int fd)
{
    int fl = fcntl(fd, F_GETFL);
    if(fl < 0){
        ERROR("fcntl");
    }

    fcntl(fd, F_SETFL, fl | O_NONBLOCK);
}

static int NoBlockRead(int client_fd, char * buff, size_t size)
{
    int read_size = 0;
    for(;;)
    {
        int cur_size = read(client_fd, buff + read_size, 1);
        read_size += cur_size;
        
        if(cur_size < 0 && errno == EAGAIN){
            break;
        }
        if(read_size > size){
            perror("read more than size");
            return -1;
        }
    }
    return read_size + 1;
}

void ProcessConnect(int listen_fd, int epoll_fd)
{
    struct sockaddr_in client_addr;
    socklen_t socklen = sizeof(client_addr);
    int client_fd = accept(listen_fd, (struct sockaddr *)&client_addr, &socklen); 
    if(client_fd < 0)
        ERROR("accept error");

    SetNoBlock(client_fd);
    struct epoll_event event;
    event.events = EPOLLIN | EPOLLET;
    event.data.fd = client_fd;
    
    if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &event))
        ERROR("accept error");
}
void ProcessRequest(int client_fd, int epoll_fd)
{
    char buff[1024] = { 0 };
    size_t size = NoBlockRead(client_fd, buff, sizeof(buff) - 1);
    
    if(size < 0){
        perror("read error");
        return;
    }
    if(size == 0){
        close(client_fd);
        epoll_ctl(epoll_fd, EPOLL_CTL_DEL, client_fd, NULL);
        return;
    }
    
    std::cout << "client: " << buff << std::endl;
    memset(buff, 0, 1024);
    write(client_fd, "receive", 7);
}
Waorange
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
io多路复用中的epoll函数详解
Science_Tec的博客
04-02 1554
epoll介绍 epoll提供了三个函数，epoll_create、epoll_ctl和epoll_wait。 1 首先创建一个epoll对象， 2 然后使用epoll_ctl对这个对象进行操作（添加、删除、修改），把需要监控的描述符加进去，这些描述符将会以epoll_event结构体的形式组成一颗红黑树 3 接着阻塞在epoll_wait，进入大循环，当某个fd上有事件发生时，内核将会把其对应的结构体放入一个链表中，返回有事件发生的链表。 epoll的三个函数介绍 int epoll_create
多路复用I/O-epoll
最新发布
技术鱼的博客
06-14 760
在网络中实现IO多路复用的技术，最常用的就是(select, poll，epoll)三种模型，但是select 受限于底层的实现，随着管理fd数量的增多，造成轮询效率下降。进而出现了epoll模型，epoll 模型底层实现是采用红黑树，不会受限于检测句柄的数量。略。
Linux程序设计之IO多路复用(API:epoll)
qq_43213240的博客
05-12 141
Linux程序设计之IO多路复用(API:epoll)
I/O多路复用epoll
ZZU_LGY
04-09 3947
epoll() 是 Linux 内核提供的高效的 I/O 多路复用机制。相对于 select() 和 poll()，它在处理大量文件描述符时更加高效和稳定，因此在高并发网络编程中得到了广泛应用。size：是创建新的 epoll 实例时指定的红黑树节点数量，目前已经没有实际作用；epfd：是 epoll 实例的描述符；op：是对 epoll 实例中的文件描述符进行添加、修改或删除的操作类型，包括 EPOLL_CTL_ADD，EPOLL_CTL_MOD 和 EPOLL_CTL_DEL；fd。
IO多路复用之epoll
是蛋筒啊的博客
07-14 3344
IO多路复用之epoll 认识epoll 由于poll并没有很大程度的解决select中的缺点，而且还带来了一些额外的开销。在处理大量socket时，select和poll要进行频繁的拷贝和遍历，效率低。所以poll也不建议使用。下面介绍的epoll不会随文件描述符的增多而开销变大，基本上解决了上述问题，被大家广泛使用。 函数原型： 创建一个epoll句柄，用来控制和等待大量的文件...
IO多路复用之epoll全面总结(必看篇)
09-15
在Linux系统中，epoll是针对IO多路复用的一种高效实现，尤其适用于大规模并发连接的场景。以下是关于epoll的详细总结： 1. **基本概念** - **epoll** 是在Linux 2.6内核引入的，是对早期的`select`和`poll`函数的...
IO多路复用之epoll实例
04-23
**IO多路复用之epoll实例** IO多路复用是一种高效的系统调用机制，允许单个进程监视多个文件描述符，等待数据就绪，而无需为每个描述符创建单独的线程或轮询。在Linux系统中，epoll是实现IO多路复用的一种高效方法...
多路IO复用-epoll，通过epoll实现事件通知，实现了水平（阻塞），边缘（非阻塞）触发
04-04
`epoll`是Linux系统提供的一种I/O复用机制，它是I/O多路复用技术的一种优化实现，特别是在高并发场景下表现优秀。本篇将深入探讨`epoll`的工作原理、两种触发模式以及其在实际应用中的价值。 首先，理解`epoll`的...
IO多路复用select和epoll.md
03-07
多路复用
IO多路复用之epoll——完整代码
02-10
三种IO多路复用机制： 一：select 二：poll 三：epoll 以上三种IO多路复用的完整代码，皆可以在我的资源列表中获取下载： 资源列表：http://download.csdn.net/user/qiulanzhu
IO多路复用之epoll函数详解
lixungogogo的博客
08-17 7571
epoll　　 在linux的网络编程中，很长的时间都在使用select来做事件触发。在linux新的内核中，有了一种替换它的机制，就是epoll。 　　相比于select，epoll最大的好处在于它不会随着监听fd数目的增长而降低效率。因为在内核中的select实现中，它是采用轮询来处理的，轮询的fd数目越多，自然耗时越多。 　　相对于select和poll来说，epoll更加灵活，没有描述符
IO模式 epoll详解
cyx1812431306的博客
08-12 476
参考链接一 参考链接二 复用技术：在单条信道上处理多个时间，用单个线程处理多个事件。 这里所说的IO主要指的是网络IO，在Linux中一切皆文件，因此网络IO常用文件描述符fd表示。 select、epoll对比 用户态将文件拷贝入内核态的方式 select：创建三个描述符集合并拷贝入内核，分别监听读、写、异常动作。受到单个进程（select线程）可以打开fd数量限制，默认是1024； epoll：执行epoll_create函数会在内核的高速cache区建立红黑树和就绪链表(存储已经就绪的文件描述符
epoll—IO多路复用之epoll总结
lqsnjust的博客
10-30 1020
1、基本知识 　　epoll是在2.6内核中提出的，是之前的select和poll的增强版本。相对于select和poll来说，epoll更加灵活，没有描述符限制。epoll使用一个文件描述符管理多个描述符，将用户关系的文件描述符的事件存放到内核的一个事件表中，这样在用户空间和内核空间的copy只需一次。 2、epoll接口 　　epoll操作过程需要三个接口，分别如下： #includ...
select、poll和epoll的区别和 IO多路复用模型讲解
qq_34802511的博客
08-09 4508
select、poll和epoll的区别和 IO多路复用模型讲解 IT生涯 2018-07-12 22:28:27 select、poll和epoll的区别 在linux没有实现epoll事件驱动机制之前，我们一般选择用select或者poll等IO多路复用的方法来实现并发服务程序。在大数据、高并发、集群等一些名词唱的火热之年代，select和poll的用武之地越来越有限了，风头已经被epo...
深入理解IO复用技术之epoll
HelloWorld搬运工
05-18 716
个人博客请访问http://www.x0100.top 1.写在前面 今天一起来学习一下高并发实现的的重要基础：I/O复用技术 & epoll原理。 通过本文你将了解到以下内容： IO复用的概念 epoll出现之前的IO复用工具 epoll三级火箭 epoll底层实现 ET模式&LT模式 一道腾讯面试题 epoll惊群问题 温馨提示：技术文章涉及很多细节都会比较晦涩，反复琢磨才...
epoll原理详解及epoll反应堆模型
LiuenshengUp的博客
11-12 901
设想一个场景：有100万用户同时与一个进程保持着TCP连接，而每一时刻只有几十个或几百个TCP连接是活跃的(接收TCP包)，也就是说在每一时刻进程只需要处理这100万连接中的一小部分连接。那么，如何才能高效的处理这种场景呢？进程是否在每次询问操作系统收集有事件发生的TCP连接时，把这100万个连接告诉操作系统，然后由操作系统找出其中有事件发生的几百个连接呢？实际上，在Linux2.4版本以前，那时...
IO多路复用---epoll详细介绍及编程使用
但行前路 无问西东
09-27 200
引出epoll epoll是在2.6内核中提出的，是之前的select和poll的增强版本。相对于select和poll来说，epoll更加灵活，没有描述符限制。epoll使用一个文件描述符管理多个描述符，将用户关系的文件描述符的事件存放到内核的一个事件表中，这样在用户空间和内核空间的copy只需一次。 前两篇介绍了select和poll,它们的接口为： int select(int nfds, ...
十七、 epoll实现I/O复用
Mark_404的博客
08-10 151
文章目录epoll理解与应用使用epoll改写回声服务端条件触发和边缘触发条件触发边缘触发使用边缘触发的回声服务器端边缘触发优点 这一章的目的与I/O复用有关，之前我们 谈到的基于select函数实现的I/O复用技术，由于该技术是一个非常古老的技术，不适用于现代高并发的环境下的使用。因此需要借用新技术来替代select函数的I/O复用。 epoll理解与应用 理解epoll还需对照select函数进行对比，一般实现复用主要有三步： 创建保存文件描述符的空间 向这个空间注册或注销文件描述符 监控空间内的
epoll io多路复用怎么理解
04-08
Epoll是一种高效的I/O多路复用机制，可以同时处理多个IO事件，减少系统调用次数，提高程序的性能。在使用epoll时，首先需要创建一个epoll对象，然后将需要监听的文件描述符加入到epoll对象中，在epoll_wait函数中...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值