IO多路复用之select和epoll（详细注释）

最新推荐文章于 2021-12-19 17:49:00 发布
最新推荐文章于 2021-12-19 17:49:00 发布
阅读量525 收藏
点赞数 1
分类专栏： 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qingqiulengya/article/details/52200588
版权 
select：
#include<stdio.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<assert.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/types.h>


void usage(char * argv)
{
                printf( "%s\n",argv);            
}

int startup(char * ip,int port)
{
                 int listen_socket=socket(AF_INET,SOCK_STREAM,0);
                 if(listen_socket<0)
                {
                                perror( "socket");
                                exit(1);
                }

                 struct sockaddr_in local;
                local.sin_family=AF_INET;
                local.sin_port=htons(port);
                local.sin_addr.s_addr=inet_addr(ip);

                 //绑定
                 if(bind(listen_socket,(struct sockaddr*)&local,sizeof(local))<0)
                {
                                perror( "bind");
                                exit(2);
                }              
                
                 //监听
                 if(listen(listen_socket,5))
                {
                                perror( "listen");
                                exit(3);
                }
                
                 return listen_socket;
}

                 int fds[64];
int main(int argc,char* argv[])
{
                 if(argc!=3)
                {
                                usage(argv[0]);
                                exit(1);
                }

                 char*ip= argv[1];
                 int port=atoi(argv[2]);

                 int listen_socket=startup(ip,port);//创建一个描述本地IP和端口号的套接字
                 struct sockaddr_in peer;//保存远端的IP和端口信息
                socklen_t len= sizeof(peer);

                 int max_fd=-1;//文件描述符最大值
                fd_set writes; //写文件描述符集
                fd_set reads; //读文件描述符集
                 int new_socket=-1;

                 int fds_num=sizeof (fds)/sizeof(fds[0]);
                 int i=0;

                 for(;i<fds_num;i++)
                {
                                fds[i]=-1;
                }

                fds[0]=listen_socket; //将listen_socket写入到文件描述符数组中
                
                 int done=0;
                 while(!done)
                {
                                 //每次循环将读文件和写文件描述集进行初始化
                                FD_ZERO(&writes);
                                FD_ZERO(&reads);

                                 struct timeval _timeout={5,0};

                                 for(i=0;i<fds_num;i++)
                                {
                                                 if(fds[i]>0)
                                                {
                                                                FD_SET(fds[i],&reads);//将需要测试的fd添加到fd_set中
                                                                 if(fds[i]>max_fd)
                                                                {
                                                                                max_fd=fds[i];//获取最大文件描述符
                                                                }
                                                }
                                }
                                
                                 switch(select(max_fd+1,&reads,&writes,NULL,&_timeout))
                                {
                                                 case 0:
                                                                printf( "timeout\n");
                                                                 break;
                                                 case -1:
                                                                perror( "select");
                                                                 break;
                                                 default:
                                                                {
                                                                                 for(i=0;i<fds_num;i++)//轮询查看所有的fd
                                                                                {
                                                                                                 if(fds[i]=listen_socket&&FD_ISSET(fds[i],&reads))//用于检查某个fd在select后相应的位是否还为1（这里接收的是本地监听套接字）
                                                                                                {
                                                                                                                new_socket=accept(listen_socket,( struct sockaddr*)&peer,&len);
                                                                                                                 if(new_socket<0)
                                                                                                                {
                                                                                                                                perror( "accept");
                                                                                                                                 continue;
                                                                                                                }
                                                                                                                printf( "conect succeed:%d\n" ,new_socket);//等待接收远端的套接字成功
                                                                                                                 for(i=0;i<fds_num;i++)
                                                                                                                {
                                                                                                                                 if(fds[i]==-1)
                                                                                                                                {
                                                                                                                                                fds[i]=new_socket;//将创建好的远端套接字加入到fd数组中
                                                                                                                                                 break;
                                                                                                                                }

                                                                                                                }
                                                                                                                }
                                                                                                 else if (fds[i]>0&&FD_ISSET(fds[i],&reads))//监听的是远端套接字，可以进行数据发送和读写了
                                                                                                {
                                                                                                                 char buf[1024];
                                                                                                                ssize_t s=read(fds[i],buf,sizeof (buf)-1);

                                                                                                                 if(s>0)
                                                                                                                {
                                                                                                                                buf[s]= '\0';
                                                                                                                                printf( "%s\n",buf);
                                                                                                                }
                                                                                                                 else if (s==0)
                                                                                                                {
                                                                                                                                fds[i]=-1;
                                                                                                                                printf( "client is closed\n");
                                                                                                                }
                                                                                                                 else
                                                                                                                                perror( "read");
                                                                                                }
                                                                                                 else
                                                                                                                  continue;
                                                                                }
                                                                }

                                }
                }

                 return 0;
}


epoll：

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

void usage(char* argv)
{
    printf("usage:[ip] [port]\n",argv);
}

int startup(const char*_ip,int _port)//创建本地套接字
{
    int listen_socket=socket(AF_INET,SOCK_STREAM,0);
    if(listen_socket<0)
    {
        perror("socket");
        exit(2);
    }

    int opt=1;
    setsockopt(listen_socket,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));//防止client断开后还继续占用                                   server一段时间

    struct sockaddr_in local;
    local.sin_family=AF_INET;
    local.sin_port=htons(_port);
    local.sin_addr.s_addr=inet_addr(_ip);

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

    if(listen(listen_socket,5)<0)
    {
        perror("listen");
        exit(4);
    }

    return listen_socket;
}

int main(int argc,char* argv[])
{
    if(argc!=3)
    {
        usage(argv[1]);
        exit(1);
    }    

    int listen_sock=startup(argv[1],atoi(argv[2]));

    int epfd=epoll_create(256);//创建一个epoll句柄
    if(epfd<0)
    {
        perror("epoll_create");
        exit(2);
    }

    struct epoll_event _ev;//需要监听的事件
    _ev.events=EPOLLIN;
    _ev.data.fd=listen_sock;

    epoll_ctl(epfd,EPOLL_CTL_ADD,listen_sock,&_ev);//先注册要监听事件的类型（第二参数表示对fd的动作），_ev即是所要监听的的事件

    struct epoll_event revs[64];

    int timeout=-1;
    int num=0;
    int done=0;

    while(!done)
    {
        switch((num=epoll_wait(epfd,revs,64,timeout)))//将监听发生过的事件赋值到revs中
        {
            case 0:
                printf("timeout\n");
                break;
            case -1:
                printf("epoll_wait\n");
                break;
            default://就绪文件描述符的值，通过映射找到相关的文件描述符
                {
                    struct sockaddr_in peer;
                    socklen_t len=sizeof(peer);
                    int i=0;
                    for(;i<num;i++)//遍历的是已经等待成功的事件的数目（和select的区别，select是遍历自己定义的整个的文件描述符的数组）
                    {
                        int rsock=revs[i].data.fd;
                        if(rsock==listen_sock&&\
                        (revs[i].events&EPOLLIN))
                        {
                            int new_fd=accept(listen_sock,(struct sockaddr*)&peer,&len);//接收远端的套接字
                            if(new_fd>0)
                            {
                                printf("get a new client:%s:%s\n",inet_ntoa(peer.sin_addr),ntohs(peer.sin_port));
                    //            set_nonblock(new_fd);
                                _ev.events=EPOLLIN|EPOLLET;
                                _ev.data.fd=new_fd;
                                epoll_ctl(epfd,EPOLL_CTL_ADD,new_fd,&_ev);
                            }
                        }
                        else//远端的套接字已经获取成功，可以进行数据的发送和读写了
                        {
                            if(revs[i].events&EPOLLIN)
                            {
                                char buf[1024];
                                ssize_t s=read(rsock,buf,sizeof(buf));
                                if(s>0)
                                {
                                    buf[s]='\0';
                                    printf("client:%s\n",buf);

                                    _ev.events=EPOLLOUT|EPOLLET;
                                    _ev.data.fd=rsock;
                                    epoll_ctl(epfd,EPOLL_CTL_MOD,rsock,&_ev);
                                }
                                else if(s==0)
                                {
                                    printf("client is closed...:%d\n",rsock);
                                    epoll_ctl(epfd,EPOLL_CTL_DEL,rsock,NULL);
                                    close(rsock);
                                }
                                else
                                {
                                    perror("read");
                                }

                            }
                            else if(revs[i].events&EPOLLOUT)
                            {
                                const char* msg="HTTP/1.0 200 OK\r\n\r\n<html><h1>hello bvit!</h1></html>\r\n";
                                write(rsock,msg,strlen(msg));
                                epoll_ctl(epfd,EPOLL_CTL_DEL,rsock,NULL);
                                close(rsock);
                            }

                        }

                    }
                }
        }
    }
}


总结：select是先将相应的套接字添加到文件描述符中，进过select返回，然后经过将所有遍历整个文件描述符数组，并且看对应的fd是否在对应的文件描述符集中也为1，如果不是1则跳过这一个fd，对下一个fd进行判断；epoll是先创建一个epoll句柄，然后再注册一个自己想要的事件，然后通过epoll_ctl函数将本地的fd添加到epoll模型中，同时对这个fd要监听的事件为上一步注册的事件。让后让epoll模型循环等待，等待成功则将监听发生过的事件放在一个事件数组里面，下来就可以对这个已近发生过的事件的数组进行遍历和相应判断，这样这个遍历的成本较select有很大的减小，所以它高效。

qingqiulengya
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
IO多路复用之select、poll、epoll之间的区别总结
yunfan
07-10 2203
select、poll、epoll都是IO多路复用的机制。IO多路复用就是通过一种机制，让一个进程/线程可以监视多个描述符，一旦某个描述符就绪（一般是读写就绪），能够通知应用程序进行相应的读写操作。I/O复用虽然能同时监听多个文件描述符，当其本质上还是同步IO模型，因为需要在读写事件就绪后程序自己负责进行读写事件的处理，而这个读写过程是阻塞的。如果要实现并发，只能使用多进程/多线程等编程手段了。 ...
select、poll和epoll的区别和 IO多路复用模型讲解
qq_34802511的博客
08-09 4507
select、poll和epoll的区别和 IO多路复用模型讲解 IT生涯 2018-07-12 22:28:27 select、poll和epoll的区别 在linux没有实现epoll事件驱动机制之前，我们一般选择用select或者poll等IO多路复用的方法来实现并发服务程序。在大数据、高并发、集群等一些名词唱的火热之年代，select和poll的用武之地越来越有限了，风头已经被epo...
网络IO select epoll
秦涧泉的博客
04-22 154
int iResult = recv(s, buffer,1024); /*设置非阻塞模式，立即返回*/ int iResult = ioctlsocket(s, FIOBIO, (unsigned long *)&ul); iResult = recv(s, buffer,1024); //5种io...
Linux IO模式及 select、poll、epoll详解
LEandLA的博客
12-19 257
1、https://segmentfault.com/a/1190000003063859
IO复用： select 和poll 到epoll
weixin_30644369的博客
09-10 99
linux 提供了select、poll和epoll三种接口来实现多路IO复用。下面总结下这三种接口。 select 该函数允许进程指示内核等待多个事件中的任何一个发生，并只在有一个或多个事件发生或经历一段指定的时间后才唤醒它。 函数接口： 1: #include <sys/select.h> 2: #include <sys...
IO多路复用之epoll全面总结(必看篇)
09-15
IO多路复用技术在高并发服务器编程中扮演...总之，epoll通过其高效和灵活的设计，成为现代Linux服务器开发中首选的IO多路复用机制。正确理解和使用epoll接口及其工作模式，对于构建高性能、可扩展的网络服务至关重要。
IO多路复用select和epoll.md
03-07
多路复用
select和epoll实现多路复用.zip
05-20
实验报告`epoll和select实现多路复用.docx`应该详细记录了实验的步骤、代码实现、测试过程以及分析结果。通过阅读报告，你可以深入理解这两种多路复用方法在实际应用中的差异，以及它们对系统资源的利用情况。 总结...
Linux IO多路复用之epoll网络编程
09-15
`epoll`提供了`select()`、`poll()`等IO多路复用函数的增强版本。与`select`和`poll`相比，`epoll`具有更高的性能和可扩展性，因为它使用了内核事件通知机制，减少了不必要的系统调用和上下文切换。 在`epoll`模型...
IO模型(select, poll, epoll的区别和原理)
见贤思齐
09-08 8111
参考http://blog.csdn.net/blueboy2000/article/details/4485874 参考http://blog.csdn.net/suxinpingtao51/article/details/46314097 参考《unix网络编程》 五种I/O模型 阻塞I/O：应用程序调用一个IO函数，导致应用程序阻塞，如果数据已经准备好，从内核拷贝到用
Unix下可用的5种I/O模型
放牛娃的博客
04-08 154
先列举一下Unix下可用的5种I/O模型： 阻塞式I/O 非阻塞式I/O I/O复用 信号驱动I/O 异步I/O 对各种模型讲个故事，描述下区别： 故事情节为：老李去买火车票，三天后买到一张退票。参演人员（老李，黄牛，售票员，快递员），往返车站耗费1小时。 阻塞式I/O 我们最熟悉的I/O模型就是阻塞式I/O模型，在上图中，应用进程系统调用recvfrom接收数据，但是此时内核缓冲区中数据报还未准备好，所以应用进程会一直阻塞直到内核缓冲区有数据报到达且被复制到应用进程缓冲区 例子： 老李去火车站买票，
IO多路复用之select、poll、epoll
吹雪的专栏
07-30 382
IO多路复用是指内核一旦发现进程指定的一个或者多个IO条件准备读取，它就通知该进程。 与多进程和多线程技术相比，I/O多路复用技术的最大优势是系统开销小，系统不必创建进程/线程，也不必维护这些进程/线程，从而大大减小了系统的开销。 目前支持I/O多路复用的系统调用有 select，pselect，poll，epoll，I/O多路复用就是通过一种机制，一个进程可以监视多个描述符，一旦某个描述符就...
关于epoll和select的区别，哪些说法是正确的？----腾讯2016研发工程师在线模拟笔试题
chengonghao的博客
07-10 5496
关于epoll和select的区别，哪些说法是正确的？ 正确答案: A B C    epoll和select都是I/O多路复用的技术，都可以实现同时监听多个I/O事件的状态 epoll相比select效率更高，主要是基于其操作系统支持的I/O事件通知机制，而select是基于轮询机制 epoll支持水平触发和边沿触发两种模式 select能并
多路复用IO模型中的select和epoll
一个想写小说的程序员
11-14 1474
多路复用IO模型中的select和epoll 一，前提知识——文件描述符fd 1、文件描述符简介 首先从文件描述符开始讲起。因为，对于内核而言，所有打开的文件都是通过文件描述符引用的。那么文件描述符到底是什么？ 文件描述符（file descriptor）通常是一个小的非负整数，内核用以标识一个特定进程正在访问的文件。当打开一个现有文件或创建一个新文件时，内核向进程返回一个文件描述符。当读、写一个...
select、poll、epoll之间的区别总结[整理]
weixin_34092455的博客
08-17 3570
　　select，poll，epoll都是IO多路复用的机制。I/O多路复用就通过一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。但select，poll，epoll本质上都是同步I/O，因为他们都需要在读写事件就绪后自己负责进行读写，也就是说这个读写过程是阻塞的，而异步I/O则无需自己负责进行读写，异步I/O的实现会负责把数据从内核拷贝...
IO多路复用的select, poll, epoll之间的区别和联系总结
技术笔记
05-20 5888
IO多路复用 select, poll和epoll都是IO多路复用的模型，所以在深入了解这三个系统调用之前，需要先简单介绍一下IO多路复用。 IO多路复用是一种复用技术，复用(multiplexing)技术很普遍，例如通信中有多路时分复用（OFDM）、频分复用、码分复用。再例如我们一个办公室的人可以共用办公室的一台打印机，大家在不同的时段使用即可实现复用，这就是时分复用。 “IO多路复用”是指复用了同一个处理线程（在Java中被抽象为选择器selector），由操作系统进行托管，当与选择器绑定的socket
关于IO多路复用函数（select、poll、epoll）的一些理解
qq_40028201的博客
06-10 368
关于IO多路复用函数（select、poll、epoll）的一些理解 一、阻塞现象 什么是阻塞现象？ ​ 当一个数据流中再也没有数据，read的时候，或者，我们的流中写满了数据在去write的时候，即无数据可读和无空间可写的尴尬现象，称为阻塞现象 阻塞等待，非阻塞忙轮询 比如这个例子，送快递与收快递的例子 阻塞等待相当于快递员在送快递的过程中，客户可以空出大脑睡大觉（不占用CPU的宝贵时...
IO多路复用中，select、poll和epoll的区别
最新发布
05-14
其中，select、poll和epoll都是常用的IO多路复用机制。 1. select和poll select和poll是传统的IO多路复用机制，它们的主要区别在于数据结构和使用方式。 select使用fd_set数据结构来表示被监视的文件描述符集合，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值