io多路复用select、poll、epoll模型

已于 2023-11-01 14:08:14 修改
阅读量40 收藏
点赞数
文章标签： c++ c语言
于 2023-11-01 10:08:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38501286/article/details/134064159
版权

一、select模型
1.函数参数含义
int select(int maxfd,fd_set *rset,fd_set *wset,fd_set *eset,struct timeval *timeout);
将需要检测的fd_set集合(参数二、三、四)拷贝到内核，如果有io就绪清空fd_set集合，重新设置fd_set集合，在拷贝到用户层。

参数一：判断最大fd的值 方便内部循环判断fd是否io就绪
参数二：文件描述符可读
参数三：文件描述符可写
参数四：文件描述符异常
参数五：多久轮询一次 NULL：阻塞 0:立即返回不阻塞进程
返回值：大于0表示有io就绪事件
代码实现：

	int sockfd = socket(AF_INET,SOCK_STREAM,0);
    if(sockfd < 0)
    {
        perror("socket");
        return -1;
    }

    struct sockaddr_in seraddr;
    seraddr.sin_family = AF_INET;
    seraddr.sin_addr.s_addr = htonl(INADDR_ANY);
    seraddr.sin_port = htons(2048);
    if(-1==bind(sockfd,(struct sockaddr*)&seraddr,sizeof(struct sockaddr)))
    {
        perror("bind");
        return -1;
    }
    printf("----bind\n");
    listen(sockfd,10);

    fd_set rfds,rset;// 一个设置 一个读判断
    FD_ZERO(&rfds);
    FD_SET(sockfd,&rfds);
    int maxfd = sockfd;
    while(1)
    {
        rset = rfds;
        int nready = select(maxfd+1,&rset,NULL,NULL,NULL);//第五个参数为空表示一直等待
        if(FD_ISSET(sockfd,&rset))//判断是否有连接
        {
            struct sockaddr_in clientaddr;
            socklen_t len = sizeof(clientaddr);
            int clientfd = accept(sockfd,(struct sockaddr*)&clientaddr,&len);
            printf("accept\n");
            FD_SET(clientfd,&rfds);
            if (clientfd > maxfd) maxfd = clientfd;
        }
        int i=0;
        for(i=sockfd+1;i<=maxfd;i++)
        {
            if(FD_ISSET(i,&rset))//读事件
            {
                char buffer[128] = {0};
                int count = recv(i,buffer,sizeof(buffer),0);
                if(count == 0){
                	FD_CLR(i,&rfds);
                	close(i);
                }
                if(count > 0)
                    printf("sockfd: %d,count: %d,buffer:%s\n",sockfd,count,buffer);
            }
        }
    }

select缺点
1.参数较多 不利于维护理解
2.对io的数量是有限制的 linux1024个,windows64个。
3.每次都需要拷贝待检测的io集合
4.每次需要遍历io集合，而返回就绪集合

二、poll模型
1.函数参数含义
int poll(struct pollfd *fds, nfds_t nfds, int timeout);
参数一：struct pollfd{
int fd; 文件描述
short events;//带入的参数 POLLIN \ POLLOUT…
short revents;//返回的信息 POLLIN \ POLLOUT…
}
参数二：最大fd的值 方便内部循环判断fd是否io就绪
参数三：多久轮询一次 。NULL：阻塞 0:立即返回不阻塞进程

/*struct pollfd{
	int fd;
	short events;//带入的参数
	short revents;//返回的信息
}*/
	int sockfd = socket(AF_INET,SOCK_STREAM,0);
    if(sockfd < 0)
    {
        perror("socket");
        return -1;
    }

    struct sockaddr_in seraddr;
    seraddr.sin_family = AF_INET;
    seraddr.sin_addr.s_addr = htonl(INADDR_ANY);
    seraddr.sin_port = htons(2048);
    if(-1==bind(sockfd,(struct sockaddr*)&seraddr,sizeof(struct sockaddr)))
    {
        perror("bind");
        return -1;
    }
    printf("----bind\n");
    listen(sockfd,10);
    
    struct pollfd fds[1024] = {0};
    fds[sockfd].fd=sockfd;
    fds[sockfd].events = POLLIN;
    int maxfd = sockfd;//遍历次数少一些 fd按递增的
    while(1)
    {
        int nready = poll(fds,maxfd+1,-1);
        if(fds[sockfd].revents & POLLIN)
        {
            struct sockaddr_in clientaddr;
            socklen_t len = sizeof(clientaddr);
            int clientfd = accept(sockfd,(struct sockaddr*)&clientaddr,&len);
            printf("accept\n");
            fds[clientfd].fd = clientfd;
            fds[clientfd].events = POLLIN;
            if (clientfd > maxfd) maxfd = clientfd;
        }
        int i = 0;
        for (i = sockfd+1;i <= maxfd;i ++) {
            if (fds[i].revents & POLLIN) {
                char buffer[128] = {0};
                int count = recv(i,buffer,sizeof(buffer),0);
                if (count == 0) {
                    fds[i].fd = -1;
                    fds[i].events = 0;		
                    close(i);
                    break; 
                }
                if(count > 0)
                    printf("sockfd: %d,count: %d,buffer:%s\n",sockfd,count,buffer);
            }
        }
    }

poll 与select类似也是采用轮询的方式，poll对文件描述符没有1024个限制，使用链表存储fd

三、epoll模型
1.函数含义
int epoll_create(int size);//参数没有意义 大于0就行
创建一个新的epoll实例并返回一个引用该实例的文件描述符,会创建一个红黑树和io就绪队列。
epoll_crl(int epfd,int op,int fd,struct epoll_event *event);
添加修改删除特定文件描述符到epoll集中（红黑树）。
参数一：epoll_create创建的fd返回值
参数二：EPOLL_CTL_ADD 添加fd到红黑树
EPOLL_CTL_DEL 删除红黑树上fd的值
EPOLL_CTL_MOD 修改红黑树上fd的值
参数三：具体的网络fd，scokfd,clientfd
参数四： typedef union epoll_data {
void ptr;
int fd;
__uint32_t u32;
__uint64_t u64;
} epoll_data_t;//保存触发事件的某个文件描述符相关的数据
struct epoll_event {
__uint32_t events; / epoll event / EPOLLIN读 EPOLLOUT写 EPOLLLT水平触发 EPOLLET边缘触发
epoll_data_t data; / User data variable */
};
int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
等待I/O事件，如果当前没有可用的事件，则阻塞调用线程。
参数一：epoll_create创建的fd返回值
参数二：接口的返回参数，epoll把发生的事件的集合从内核复制到 events数组中
参数三：与参数二预分配的数组的大小是相等的
参数四：表示在没有检测到事件发生时最多等待的时间，超时时间(>=0)，单位是毫秒ms，-1表示阻塞，0表示不阻塞
返回值：成功返回需要处理的事件数目。失败返回0，表示等待超时。

//面向io处理: 通过listenfd进行accept 通过clientfd进行读写
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>

#include <fcntl.h>
#include <pthread.h>

#include <sys/poll.h>
#include <sys/epoll.h>
int main()
{
    int sockfd = socket(AF_INET,SOCK_STREAM,0);
    if(sockfd < 0)
    {
        perror("socket");
        return -1;
    }

    struct sockaddr_in seraddr;
    seraddr.sin_family = AF_INET;
    seraddr.sin_addr.s_addr = htonl(INADDR_ANY);
    seraddr.sin_port = htons(2048);
    if(-1==bind(sockfd,(struct sockaddr*)&seraddr,sizeof(struct sockaddr)))
    {
        perror("bind");
        return -1;
    }
    printf("----bind\n");
    listen(sockfd,10);

    int epfd = epoll_create(1); 
    struct epoll_event ev;
    ev.events = EPOLLIN;
    ev.data.fd = sockfd;
    epoll_ctl(epfd,EPOLL_CTL_ADD,sockfd,&ev);
    struct epoll_event events[1024] = {0};
    while(1)
    {
        int nready = epoll_wait(epfd,events,1024,-1);
        if (nready < 0) continue;
        int i = 0;
        for(i = 0;i < nready;i++)
        {
            int connfd = events[i].data.fd;
            if(sockfd == connfd)	//处理listenfd 面向io分类
            {
                struct sockaddr_in clientaddr;
                socklen_t len = sizeof(clientaddr);
                int clientfd = accept(sockfd,(struct sockaddr*)&clientaddr,&len);
                printf("accept\n");
                ev.events = EPOLLIN;
                ev.data.fd = clientfd;
                epoll_ctl(epfd,EPOLL_CTL_ADD,clientfd,&ev);
            }
            else if(events[i].events & EPOLLIN) //处理clientfd
            {
                char buffer[128] = {0};
                int count = recv(connfd,buffer,sizeof(buffer),0);
                if(count == 0)
                {
                    epoll_ctl(epfd,EPOLL_CTL_DEL,connfd,NULL);
                    close(i);
                }
                if(count > 0)
                    printf("sockfd: %d,count: %d,buffer:%s\n",sockfd,count,buffer);
                continue;
            }
        }
    }
}

2.epoll水平触发LT(默认触发方式)： io缓冲区有数据或有空间写就会一直触发， 不断的通过epoll_wait()返回
测试：服务器每次接受10个字节，客户端每次发送32字节

while(1)
    {
        int nready = epoll_wait(epfd,events,1024,-1);
        printf("epoll_wait\n");
        if (nready < 0) continue;
        int i = 0;
        for(i = 0;i < nready;i++)
        {
            int connfd = events[i].data.fd;
            if(sockfd == connfd)	//处理listenfd 面向io分类
            {
                struct sockaddr_in clientaddr;
                socklen_t len = sizeof(clientaddr);
                int clientfd = accept(sockfd,(struct sockaddr*)&clientaddr,&len);
                printf("accept\n");
                ev.events = EPOLLIN;
                ev.data.fd = clientfd;
                epoll_ctl(epfd,EPOLL_CTL_ADD,clientfd,&ev);
            }
            else if(events[i].events & EPOLLIN) //处理clientfd
            {
                char buffer[10] = {0};//每次接受10个数据
                int count = recv(connfd,buffer,sizeof(buffer),0);
                if(count == 0)
                {
                    epoll_ctl(epfd,EPOLL_CTL_DEL,connfd,NULL);
                    close(i);
                }
                if(count > 0)
                    printf("sockfd: %d,count: %d,buffer:%s\n",sockfd,count,buffer);
                continue;
            }
        }
    }

在这里插入图片描述
3.epoll边缘触发ET： io缓冲区状态变化就会触发，读：来数据就触发一次，写：写缓冲区从满到有空间才会触发一次
测试：服务器每次接受10个字节，客户端每次发送32字节

    while(1)
    {
        int nready = epoll_wait(epfd,events,1024,-1);
        if (nready < 0) continue;
        int i = 0;
        for(i = 0;i < nready;i++)
        {
            int connfd = events[i].data.fd;
            if(sockfd == connfd)
            {
                struct sockaddr_in clientaddr;
                socklen_t len = sizeof(clientaddr);
                int clientfd = accept(sockfd,(struct sockaddr*)&clientaddr,&len);
                printf("accept\n");
                ev.events = EPOLLIN | EPOLLET;//设置边缘触发
                ev.data.fd = clientfd;
                epoll_ctl(epfd,EPOLL_CTL_ADD,clientfd,&ev);
            }
            else if(events[i].events & EPOLLIN)
            {
                char buffer[10] = {0};
                int count = recv(connfd,buffer,sizeof(buffer),0);
                if(count == 0)
                {
                    epoll_ctl(epfd,EPOLL_CTL_DEL,connfd,NULL);
                    close(i);
                }
                if(count > 0)
                    printf("sockfd: %d,count: %d,buffer:%s\n",sockfd,count,buffer);
                continue;
            }
        }
    }

在这里插入图片描述
点击再次发送，继续读出10个字节
在这里插入图片描述
通过循环读取解决读不完整情况

 while((count = recv(connfd,buffer,sizeof(buffer),0)) > 0)
 {
     if(count == 0)
     {
         epoll_ctl(epfd,EPOLL_CTL_DEL,connfd,NULL);
         close(i);
     }
     else if(count < 0)
     {
          if (errno == EAGAIN) {
              break;
          }
          epoll_ctl(epfd,EPOLL_CTL_DEL,connfd,NULL);
          close(i);
      }
      else if(count > 0)
      {
      	  printf("sockfd: %d,count: %d,buffer:%s\n",sockfd,count,buffer);
          memset(buffer,0,sizeof(buffer));
      }                       
      continue;
 }

在这里插入图片描述

4.LT与ET应用场景
tcp协议有粘包的过程,通常在业务数据包首部加个长度或者加分隔符(redis)
以定义包长为例,读两次，先读长度，在读内容
short length = 0;
recv(fd,&length ,2,0);
length = ntohs(length);
recv(fd,buffer,length,0);

redis协议格式如下：
*3\r\n
$3\r\n //长度
SET\r\n //内容
$6\r\n //长度
mykey\r\n
$5\r\n //长度
12345\r\n
水平触发：适合上述情况
边缘触发：一次性数据读不完的情况 比如发送一个大文件

5.一次发送一个大文件（超过读写缓冲区，读写缓冲区都设置为16384字节）

#写缓冲区大小
$ sysctl net.ipv4.tcp_wmem
net.ipv4.tcp_wmem = 4096     16384   4194304
#更改写缓冲区大小
$ sysctl -w net.ipv4.tcp_wmem="4096 16384 8388608"
#读缓冲区大小
sysctl net.ipv4.tcp_rmem
net.ipv4.tcp_rmem = 4096     131072  6291456
#更改发送缓冲区大小
$ sysctl -w net.ipv4.tcp_rmem="4096 16384 8388608"

在这里插入图片描述
ET模式下，发送47411字节数据，只调用一次epoll_wait
在这里插入图片描述
LT模式下，发送47411字节数据，会多次调用epoll_wait

总是不在
关注
IO 多路复用：select/poll/epoll 实现原理及区别
梦~'
02-07 900
I/O 多路复用：select/poll/epoll 实现原理及区别
IO多路复用select/poll/epoll
一个后端菜鸟的博客
03-18 598
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、io多路复用二、select/poll/epoll1.select2. poll3.epoll仓库文章 前言 一、io多路复用 使用场景：一个高性能的网络服务器，可以让多个客户端同时使用 （bs）并且可以获取这些客户端的请求 并处理 怎么处理这些请求的 高并发状况 如果使用多线程 可以做 但是 多线程的使用需要上下文的切换（需要处理一些句柄） 客户端比较多的时候 代价是非常高的 二、select/poll/epoll .
IO多路复用 select/poll/epoll
DiligentDog的博客
11-06 527
IO多路复用 select/poll/epoll
IO 多路复用 select、poll、epoll
RichardGeek的博客
06-07 1075
Socket编程IO 多路复用模型。系统Kernel内核支持方式 select、poll、epoll
IO多路复用select、poll、epoll
MrWangHao的博客
09-20 301
​ select的调用会阻塞到有文件描述符可以进行IO操作或被信号打断或者超时才会返回。select将监听的文件描述符分为三组，每一组监听不同的需要进行的IO操作。readfds是需要进行读操作的文件描述符，writefds是需要进行写操作的文件描述符，exceptfds是需要进行异常事件处理的文件描述符。这三个参数可以用NULL来表示对应的事件不需要监听。 ​
redis中的IO多路复用select和epoll
yxkong的专栏
01-05 722
基本概念I/O多路复用是一种同步I/O模型，实现一个线程可以监视多个文件句柄；一旦某个文件句柄就绪，就能够通知线程进行相应的读写操作；没有文件句柄就绪时会阻塞应用程序。多路是指网络连接，复用指的是同一个线程。I/O多路复用模型是建立在内核提供的多路分离函数select基础之上的，使用select函数可以避免同步非阻塞IO模型中轮询等待的问题。可以先了解下fd和socketlinux中的文件描述符与套接字socketredis中的使用在redis中支持四种类型的实现。根据环境的不同，include进去不同的实
io多路复用select与epoll模型的实现与对比【通俗易懂】
weixin_44545838的博客
06-04 933
select和epoll都可以用来实现高并发TCP服务器，但是它们的实现方式有一些不同。在select模型中，我们需要将需要监控的文件描述符全部加入一个fd_set结构中，并对其进行轮询，查看其中是否有文件描述符的状态发生了变化。而在epoll模型中，我们只需要将需要监听的文件描述符添加到epoll实例中，当文件描述符状态发生变化时，epoll_wait函数会返回相应的事件数据。因此，与select模型相比，epoll模型更加高效。
【IO多路复用】select、poll、epoll之间的区别
欢迎来到 程序猿 的博客
09-26 1747
1、支持一个进程所能打开的最大连接数单个进程所能打开的最大连接数有FD_SETSIZE宏定义，其大小是32个整数的大小（在32位的机器上，大小就是3232，同理64位机器上FD_SETSIZE为3264），当然我们可以对进行修改，然后重新编译内核，但是性能可能会受到影响，这需要进一步的测试。poll本质上和select没有区别，但是它没有最大连接数的限制，原因是它是基于链表来存储的虽然连接数有上限，但是很大，1G内存的机器上可以打开10万左右的连接，2G内存的机器可以打开20万左右的连接。
IO多路复用之Select、Poll、Epoll详解
qq_45604814的博客
03-11 959
一.IO多路复用简介 unxi有五种IO标准 阻塞式IO 非阻塞式IO IO复用 信号驱动IO 异步IO 当多种事件同时发生的时候 阻塞IO:同一时刻只能处理一个事件，多事件使用多进程多线程，耗费内存资源。但是不必时间片轮训，节约CPU宝贵资源 非阻塞IO：提高程序执行效率。不节约CPU资源。节约内存资源 IO多路复用：select poll epoll 二.什么是I/O多路转接技术 构建一张文件描述符列表，将要监听的文件描述符添加至该列表。select poll epoll会一...
高级IO以及IO多路复用（select、poll、epoll网络编程）
qq_61635026的博客
03-09 1119
IO多路复用是一种高效的I/O处理机制，它允许在单个线程中同时监视和处理多个I/O操作，以提高程序的性能和可扩展性。 在传统的阻塞I/O模型中，每个I/O操作都会阻塞整个进程，直到该操作完成。这就意味着如果应用程序需要处理多个并发I/O操作，就需要建立多个线程或者进程来处理它们，这样就会导致系统的开销过高，并且导致可扩展性下降。 使用IO多路复用，应用程序可以将多个I/O操作注册到一个事件的循环中，然后使用一个线程来监视这些操作的状态。当其中任何一个操作就绪时，事件循环就会通知相应的应用程序，来执行相应
IO多路复用之epoll全面总结(必看篇)
09-15
在Linux系统中，epoll是针对IO多路复用的一种高效实现，尤其适用于大规模并发连接的场景。以下是关于epoll的详细总结： 1. **基本概念** - **epoll** 是在Linux 2.6内核引入的，是对早期的`select`和`poll`函数的...
【Redis】IO多路复用 及 Select、Poll、Epoll、NIO
火火的博客
12-17 2126
文章目录文件事件处理器【I/O多路复用程序】的实现文件事件的处理器连接应答处理器：命令请求处理器：命令回复处理器一次完整的客户端与服务器链接示例 文件事件处理器 Redis开发了一个文件事件处理器，文件事件处理器使用I/O多路复用（multiplexing）程序来同时监听多个套接字， 并根据套接字目前执行的任务来为套接字关联不同的事件处理器。 当被监听的套接字准备好执行 连接应答（accept）、读取（read）、写入（write）、关闭（close）等操作时， 与操作相对应的文件事件就会产生，此时，文件事
IO多路复用机制——epoll
李小恩恩子的博客
07-21 2950
高效地对海量用户提供服务，必须要让进程能同时处理很多个tcp连接。假设一个进程保持了10000条连接，如何发现哪条连接上有数据可读、可写？实现循环遍历来发现IO事件？效率太低了。epoll的通俗解释，当文件描述符的内核缓冲区非空的时候，发出可读信号进行通知，当写缓冲区不满的时候，发出可写信号通知的机制。..................
【C++】 —— string的使用
LH__1314的博客
09-16 1504
string类虽然不在STL的容器中，但string类十分重要，string类是对字符串的存储和相关操作。
【C++】【网络】【Linux系统编程】单例模式，加锁封装TCP/IP协议套接字
2301_79796701的博客
09-16 1923
给系统，表明这个套接字所期望的、还未处理的（即还在等待被接受的连接）连接请求的最大队列长度。换句话说，它告诉系统内核为这个套接字分配多大的空间来存储尚未处理的连接请求。有关套接字编程的细节和更多的系统调用课参考《UNIX环境高级编程》一书，可以在如下网站搜索电子版，该书在第16章详细的介绍了各种接口。我们可以根据自己的需求，用面向对象的思想封装出接口简洁的类。在类似添加一个该类类型的指针，该指针是静态的并且是私有成员。结构体填充，为了使不同的地址格式能和套接字绑定，需要把对应的结构体强转成通用地址结构。
标准C++（二）
m0_63127040的博客
09-18 903
在C语言中定义的全局变量、函数、结构、联合、枚举、枚举值、宏都在全局作用域下，所以当项目比较庞大时，非常容易造成命名冲突（以模块名作前缀、后缀），所以C++中选择把全局作用域进行拆分成子作用域进行管理，这些子作用域就是作名字空间。把抽象结果（利用面向对象的思维模式，思考、观察出的结果），使用用C++的语法封装出一种类似结构的自定义数据类型（复合数据类型）。使用设计好的类（结构）这种数据类型，定义出的类变量在面向对象编程语言中被称为对象（结构变量），创建类对象的行为也被称为实例化对象。int id;
C++_map_set详解
2302_77644537的博客
09-16 1065
set是按照一定次序存储元素的容器在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格的排序准则（默认是小于）进行排序。set在底层是用二叉搜索树(红黑树)实现的。map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
TMS Scripter Crack TMS Scripter is a Delphi C++ Builder
q2315702359的博客
09-19 1040
　　The integrated development environment or the IDE allows the users in process of creating script jobs during the runtime with the help of multiple cross-language scripts such as de Pascal and the Basics.　　It has support for the cross-utilization of the s
C++ 解析 RDP 协议
最新发布
道亦无名
09-22 194
远程桌面协议（Remote Desktop Protocol, RDP）是微软开发的一种网络通信协议，用于提供远程桌面会话服务。它允许用户通过网络连接至远程计算机，并像使用本地计算机一样操作远程系统。本文档将详细探讨在C++环境中如何解析RDP协议，涵盖协议层次解析、连接过程管理、数据加密解密、功能数据处理、错误与异常处理以及协议版本适配等方面。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值