I/O多路转接之epoll

最新推荐文章于 2023-05-01 23:56:54 发布
最新推荐文章于 2023-05-01 23:56:54 发布
阅读量292 收藏
点赞数
分类专栏： 网络 文章标签： io epoll
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Better_JH/article/details/72991061
版权


epoll是对select和poll的改进，表现在：
1、epoll保证了每个fd在整个过程中只会拷贝一次。
2、获取事件时，它无须遍历整个被监听的描述符集，只要遍历那些被内核I/O事件异步唤醒而加入就绪队列的描述符集合即可。
3、epoll所支持的fd上限是最大可以打开文件的数目，这个数字一般远大于2048，在1GB内存的机器上大约是10万左右，具体数目可以cat /proc/sys/fs/file-max查看,该数目与系统内存有关。
这里写图片描述
—————————————————————————————————————————————-
epoll提供了三个系统调用接口来实现上面的功能
这里写图片描述
创建一个epoll的句柄，size参数是被忽略的。当创建好epoll句柄后，它就是会占用一个fd值，在使用完epoll后，必须调用close关闭，否则可能导致fd被耗尽。当调用该函数时，操作系统则创建一个就绪队列和一个红黑树（当然还有其他的底层结构）；就绪队列用来存放就绪的fd，红黑树用来存放要监听的fd。


这里写图片描述
epoll的事件注册函数，它不同于select是在监听事件时告诉内核要监听什么类型的事件，而是在这里先注册要监听的事件类型（往红黑树上注册）。
参数1：epfd是epoll_create的返回值;
参数2：表示动作，用三个宏来表示：
EPOLL_CTL_ADD：注册新的fd到epfd中；
EPOLL_CTL_MOD：修改已经注册的fd的监听事件；
EPOLL_CTL_DEL：从epfd中删除一个fd；
参数3：fd是需要监听的fd。
参数4：是告诉内核需要监听什么事，struct epoll_event结构如下：
这里写图片描述
events可以是以下几个宏的集合：
EPOLLIN ：表示对应的文件描述符可以读（包括对端SOCKET正常关闭）；
EPOLLOUT：表示对应的文件描述符可以写；
EPOLLPRI：表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）；
EPOLLERR：表示对应的文件描述符发生错误；
EPOLLHUP：表示对应的文件描述符被挂断；
EPOLLET： 将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)来说的；
EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里；


这里写图片描述
收集在epoll监听的事件中已经就绪的事件。等待红黑树上的某个fd的某个事件就绪，若有就绪的fd,则将该fd拷贝一份放至就绪队列中（操作系统依靠回调函数来完成）。
参数2：events是分配好的epoll_event结构体数组，epoll将会把发生的事件（就绪队列）复制到events数组中（有序且全部有效）（events不可以是空指针，内核只负责把数据复制到这个events数组中，不会去帮助我们在用户态中分配内存）。
参数3：maxevents告之内核这个events有多大，这个 maxevents的值不能大于epoll_create函数的size；
参数4：timeout是超时时间（毫秒，0会立即返回，-1永久阻塞）；
返回值：
成功：返回对应I/O上已就绪的文件描述符数目；
0：表示timeout已超时；
-1：出错。
epoll的两种工作方式：
水平触发（LT）：（有数据时）一直在等，低效但是可靠。
边缘触发（ET）：有数据时即通知（只通知一次），会出现数据丢失问题，但是高效。
注： epoll默认为水平触发工作方式。可以通过epoll_ctl函数来设置。
使用epoll实现一个tcp服务器：

//server端：
#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<sys/epoll.h>
#include<stdlib.h>
#include<string.h>
int array_fds[1024];
static void Usage(const char* proc)
{
    printf("Usage:%s [local_ip][local_port]\n",proc);
}
typedef struct fd_buf
{
    int fd;
    char buf[10240];
}fd_buf_t,*fd_buf_p;
static void*  alloc_fd_buf(int fd)
{
    fd_buf_p tmp = (fd_buf_p)malloc(sizeof(fd_buf_t));
    if(!tmp)
    {
        perror("malloc");
        return NULL;
    }
    tmp->fd= fd;
    return tmp;
}
 void Default(int epollfd,int listen_sock,int num,struct epoll_event ev,struct epoll_event *evs)
{
    int i = 0;
    for(;i<num;i++)
    {
        fd_buf_p fp = (fd_buf_p)evs[i].data.ptr;
        if(fp->fd==listen_sock && (evs[i].events & EPOLLIN))
        {
            struct sockaddr_in client;
            socklen_t len=sizeof(client);
            int new_sock=accept(fp->fd,(struct sockaddr*)&client,&len);
            if(new_sock<0)
            {
                perror("accept");
                continue;
            }
            printf("new client--> %s:%d\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));
            ev.events = EPOLLIN;
            ev.data.ptr = alloc_fd_buf(new_sock);
            epoll_ctl(epollfd,EPOLL_CTL_ADD,new_sock,&ev);  
        }
        else if(fp->fd !=listen_sock)
        {
            if(evs[i].events & EPOLLIN)
            {
                ssize_t s = read(fp->fd,fp->buf,sizeof(fp->buf));
                if(s>0)
                {
                    fp->buf[s]=0;
                    printf("client say:%s\n",fp->buf);
                    ev.events = EPOLLOUT;
                    ev.data.ptr = fp;
                    epoll_ctl(epollfd,EPOLL_CTL_MOD,fp->fd,&ev);    
                }
                else if(s == 0)
                {
                    printf("client is quit!!\n");
                    close(fp->fd);
                    epoll_ctl(epollfd,EPOLL_CTL_DEL,fp->fd,NULL);
                    free(fp);
                }
                else
                {
                    perror("read");
                    close(fp->fd);
                    epoll_ctl(epollfd,EPOLL_CTL_DEL,fp->fd,NULL);
                    free(fp);
                }

            }
            else if(evs[i].events & EPOLLOUT)
            {
                const char *msg="HTTP/1.0 200 OK\r\n\r\n<html><h1>LIUJINHUA</h1></html>\r\n";
                write(fp->fd,msg,strlen(msg));
                close(fp->fd);
                epoll_ctl(epollfd,EPOLL_CTL_DEL,fp->fd,NULL);
                free(fp);
            }
        }
    }
}
int Startup(const char* _ip,int _port)
{
    int sock= socket(AF_INET,SOCK_STREAM,0);
    if(sock<0)
    {
        perror("socket");
        exit(1);
    }
    int flag = 1;
    setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&flag,sizeof(flag));

    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port= htons(_port);
    server.sin_addr.s_addr = inet_addr(_ip);
    if(bind(sock,(struct sockaddr*)&server,sizeof(server))<0)
    {
        perror("bind");
        exit(2);
    }

    if(listen(sock,10)<0)
    {
        perror("listen");
        exit(3);
    }
    return sock;
}
int main(int argc,const char* argv[])
{
    if(argc!=3)
    {
        Usage(argv[0]);
        return 1;
    }
    int listen_sock = Startup(argv[1],atoi(argv[2]));
    int epollfd = epoll_create(256);
    if(epollfd<0)
    {
        perror("epoll_create");
        close(listen_sock);
        return 2;
    }
    struct epoll_event ev;
    ev.events= EPOLLIN;
    ev.data.ptr = alloc_fd_buf(listen_sock);
    if(epoll_ctl(epollfd,EPOLL_CTL_ADD,listen_sock,&ev)!=0)
    {
        perror("epoll_ctl");
        close(epollfd);
        close(listen_sock);
        return 3;
    }
    while(1)
    {
        int num = 0;
        int timeout=-1;
        struct epoll_event evs[64];
        switch(num=epoll_wait(epollfd,evs,64,timeout))
        {
            case 0:
                printf("timeout...\n");
                break;
            case -1:
                perror("epoll_wait");
                break;
            default:
                Default(epollfd,listen_sock,num,ev,evs);
                break;
        }
    }
    close(epollfd);
    return 0;
}
//client端：
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
static void usage(const char* proc)
{
    printf("Usage:%s[server_ip][server_port]\n",proc);
}
int main(int argc,char *argv[])
{
    if(argc != 3)
    {
        usage(argv[0]);
        return 1;
    }
    int sock = socket(AF_INET,SOCK_STREAM,0);
    if(sock<0)
    {
        perror("socket");
        return 2;
    }
    struct sockaddr_in peer;
    peer.sin_family = AF_INET;
    peer.sin_port = htons(atoi(argv[2]));
    peer.sin_addr.s_addr = inet_addr(argv[1]);
    int ret = connect(sock,(struct sockaddr*)&peer,sizeof(peer));
    if(ret<0)
    {
        perror("connect");
        printf("%s\n",strerror(ret));
        return 3;
    }
    char buf[1024];
    while(1)
    {
        printf("please enter: ");
        fflush(stdout);
        ssize_t s=read(0,&buf,sizeof(buf));
        if(s<0)
        {
            perror("read");
            return 4;
        }
        buf[s-1]=0;
        write(sock,&buf,strlen(buf));
        printf("server echo: %s\n",buf);        
    }
    close(sock);
    return 0;
}

Better_JH
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
IO多路复用之epoll全面总结(必看篇)
09-15
下面小编就为大家带来一篇IO多路复用之epoll全面总结(必看篇)。小编觉得挺不错的。现在就分享给大家。也给大家做个参考。一起跟随小编过来看看吧
Linux IO多路复用之epoll网络编程
09-15
今天小编就为大家分享一篇关于Linux IO多路复用之epoll网络编程，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
深入理解epoll原理
天行健，君子以自强不息
06-03 3450
这里先补充一下三种IO多路复用的应用场景 1. select 应用场景 select 的 timeout 参数精度为 1ns，而 poll 和 epoll 为 1ms，因此 select 更加适用于实时性要求比较高的场景，比如核反应堆的控制。select 可移植性更好，几乎被所有主流平台所支持。 2. poll 应用场景 poll 没有最大描述符数量的限制，如果平台支持并且对实时性要求不高，应...
Linux IO复用区别与epoll详解
hacker00011000的专栏
08-09 2182
一、select、poll、epoll之间的区别总结[整理] 　　select，poll，epoll都是IO多路复用的机制。I/O多路复用就通过一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。但select，poll，epoll本质上都是同步I/O，因为他们都需要在读写事件就绪后自己负责进行读写，也就是说这个读写过程是阻塞的，而异步I/
select、poll、epoll之间的区别
黄亚的博客
05-11 1796
(1)select==>时间复杂度O(n) 它仅仅知道了，有I/O事件发生了，却并不知道是哪那几个流（可能有一个，多个，甚至全部），我们只能无差别轮询所有流，找出能读出数据，或者写入数据的流，对他们进行操作。所以select具有O(n)的无差别轮询复杂度，同时处理的流越多，无差别轮询时间就越长。 (2)poll==>时间复杂度O(n) poll本质上和select没有区别，它将用户传入...
I/O多路转接之 epoll
didi1663478999的博客
10-22 262
epoll 初识 按照哦man手册的说法，是为了处理大批量的句柄而做了改进的epoll 它几乎具备了之前多说的一切优点 被公认Linux2.6下性能最好的多路I/O就绪通知方法。 epoll 的相关系统调用 epoll_create int epoll_create(int size) 建立epoll 模型： 红黑树 就绪队列 回调机制 epoll_ctl（对红黑树进行操作） int e...
网络编程---I/O多路转接之epoll
MEANSWER的博客
07-24 275
I/O多路转接之epoll一级目录二级目录三级目录 I/O多路转接之select链接: link. 一级目录 二级目录 三级目录
『Linux』I/O多路转接之epoll模型
叄拾叄画生
06-24 279
poll函数。poll执行过程。poll优缺点分析。epoll。epoll相关接口。epoll工作原理。epoll使用过程。epoll的优点。epoll工作方式。
【校招 --阶段二 linux操作系统】高级I/O多路转接之epoll
qq_50408340的博客
03-15 923
epoll与之相关的系统调用 epoll_create 头文件#include<sys/epoll.h> 函数原型: int epoll_create(int size); 参数： size：szie是一个忽略的值，但是必须大于0 返回值是一个文件描述符新epoll实例的文件描述符 调用epoll_create他在底层做了什么？他在操作系统层面上创建一个epoll模型，这个epoll模型用文件描述符访问 epoll_stl 函数原型： int epoll_ctl(int epfd, int
I/O多路转接——epoll服务器代码编写
最新发布
想让你搞懂的博客
05-01 1231
在LT模式中，当我们想写时只需要将对应的文件描述符所对应的EPOLLOUT添加事件中，在我们今天的编写代码中，在whlie循环中的事件检测中，当检测到是EPOLLOUT事件时，我们就可以在回调函数中调用send函数。我们的代码耦合度太高了，数据处理的函数放在了源文件中，我们另起一个头文件，将处理函数放到该头文件中，这样业务处理是业务处理，网络服务是网络服务。
I/O多路转接之epoll模型
persistence_s的博客
08-02 344
epoll是性能最好的没有之一 epoll有三个系统调用函数 epoll_create 创建文件描述符、来标识epoll模型 epoll_ctl epoll_wait #include<stdio.h> #include <sys/epoll.h> #include <sys/types.h> #include <sys/socket.h> #include <sys/time.h>
网络连接 I/O复用 服务端代码
08-23
网络连接 使用epoll，可以不使用多线程来完成多个客户端对服务端进行传输
TCP/IP协议中的端口号
热门推荐
Better_JH的博客
05-19 1万+
TCP/IP协议中的端口号：标识本计算机应用层中的各个进程在和运输层交互时的层间接口，共有（0~65535）65536个。 端口的类别： 服务器端使用的端口号： 1、熟知端口号或系统端口号（Well Known Ports）：从0到1023。它们紧密绑定于一些服务。通常这些端口的通讯明确表明了某种服务的协议。例如：80端口实际上总是HTTP通讯，分配给WWW服务，21端口分配给FTP服务等 。
进程池&线程池原理及应用
Better_JH的博客
06-03 1371
一般我们是通过动态创建子进程（或子线程）来实现并发服务器的，但是会存在这样一些缺点： 1、动态创建进程（或线程）比较耗费时间，这将导致较慢的服务器响应。 2、动态创建的子进程通常只用来为一个客户服务，这样导致了系统上产生大量的细微进程（或线程）。进程和线程间的切换将消耗大量CPU时间。 3、动态创建的子进程是当前进程的完整映像，当前进程必须谨慎的管理其分配的文件描述符和堆内存等系统资源，否则子
TCP报文首部的URG和PSH字段
Better_JH的博客
05-26 1010
TCP报文首部的URG和PSH字段 紧急URG（URGent）：当URG=1时，表明紧急指针字段有效。发送应用进程就告诉发送方的TCP有紧急数据要传送。于是发送方TCP就把紧急数据插入到本报文段数据的最前面，而紧急数据后面的数据仍是普通数据。 推送PSH（PuSH）:当两个应用进程进行交互式的通信时，有时候一端的应用进程希望在键入一个命令后立即就能收到对方的响应。在这种情况下，TCP就可应使用推
基于TCP的socket编程
Better_JH的博客
06-02 980
socket：网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket（套接字）。 建立socket连接至少需要一对套接字，其中一个运行于客户端，称为ClientSocket ，另一个运行于服务器端，称为ServerSocket 。　 套接字之间的连接过程： 1、服务器监听：服务器端套接字并不定位具体的客户端套接字，而是处于等待连接的状态，实时监控网络状态，等待
TCP连接与释放期间的四种定时器
Better_JH的博客
05-26 869
—————————————————————————————————————————————- TCP连接与释放期间的四种定时器 1、重传计时器（retransmission timer）：为了控制丢失的报文段或丢弃的报文段，也就是对报文段确认的等待时间。当TCP发送报文段时，就创建这个特定报文段的重传计时器，可能发生两种情况：若在计时器超时之前收到对报文段的确认，则撤销计时器；若在收到对特定报文
文件描述符的重定向：dup/dup2
Better_JH的博客
06-05 705
dup/dup2：进行文件描述符的重定向即创建一个oldfd的副本。 dup：最低编号、未被使用的文件描述符是oldfd的一份拷贝。 dup2：newfd是oldfd的一份拷贝。 返回值：成功（newfd）; 失败（-1）。 基于TCP的socket编程：http://blog.csdn.net/better_jh/article/details/72846264 以基于TCP的sock
Linux下I/O多路复用(select、poll、epoll)
03-25
这三种方法都是 Linux 下实现 I/O 多路复用的技术，用于解决单个进程无法同时处理多个 I/O 任务的问题。其中 select 和 poll 是传统的实现方式，而 epoll 是新的方式，性能更好。 在使用 I/O 多路复用技术时，需要...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值