Linux基础13(I/O复用)

最新推荐文章于 2023-05-26 22:15:00 发布
最新推荐文章于 2023-05-26 22:15:00 发布
阅读量2.7k 收藏
点赞数
分类专栏： Linux基础学习 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45893523/article/details/123972344
版权

I/O复用

第十三章、I/O复用

在这里插入图片描述总而言之：需要处理多个文件描述符时，就用io复用

1.select方法

在这里插入图片描述在这里插入图片描述

1.select方法的应用-使用select方法实现服务器并发处理

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>
#include<unistd.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<fcntl.h>
#include<sys/select.h>
#include<sys/time.h>

#define MAXFD 100

void fds_init(int fds[])
{
        int i=0;
        for(;i<MAXFD;++i)
        {
                fds[i] = -1;
        }
}
void fds_add(int fds[],int fd)
{
        int i=0;
        for(;i<MAXFD;++i)
        {
                if(fds[i] == -1)
                {
                        fds[i]=fd;
                        break;
                }
        }
}
void fds_del(int fds[],int fd)
{
        int i=0;
        for(;i<MAXFD;++i)
        {
                if(fds[i]==fd)
                {
                        fds[i] = -1;
                        break;
                }
        }
}

int create_socket();
int main()
{
        int sockfd = create_socket();
        assert(sockfd != -1);

        int fds[MAXFD];
        fds_init(fds);

        fds_add(fds,sockfd);

        fd_set fdset;//把所有文件描述符放进集合中

        while(1)
        {
                FD_ZERO(&fdset);
                int maxfd=-1;

                int i=0;
                for(;i<MAXFD;++i)
                {
                        if(fds[i]!=-1)
                        {
                                FD_SET(fds[i],&fdset);
                                if(maxfd<fds[i])
                                {
                                        maxfd =fds[i];//找到数组中描述符最大的那个
                                }
                        }
                }
                struct timeval tv ={5,0};

                int n=select(maxfd+1,&fdset,NULL,NULL,&tv);
                if(n<0)
                {
                        printf("select error\n");
                        continue;
                }
                else if(n==0)
                {
                        printf("time out\n");
                        continue;
                }
                else
                {
                        int i=0;
                        for(;i<MAXFD;++i)
                        {

                                if(fds[i] == -1)
                                {continue;}

                                if(FD_ISSET(fds[i],&fdset))//检测当前描述符上有没有数据就>绪
                                {
                                //处理分两类，对于socket套接字(监听套接字)采用accept()方法
                                //对于连接套接字，采用recv（）方法
                                        if(fds[i]==sockfd)
                                        {
                                                struct sockaddr_in caddr;
                                                int len= sizeof(caddr);
                                                int c=accept(sockfd,(struct sockaddr*)&caddr,&len);
                                                if (c==-1)
                                                {
                                                continue;
                                                }
                                                printf("accept c=%d\n",c);
                                                fds_add(fds,c);
                                        }
                                        else
                                        {
                                                char buff[128]={0};
                                                int res =recv(fds[i],buff,127,0);
                                                if(res <= 0)//对方出错/关闭
                                                {
                                                        close(fds[i]);
                                                        fds_del(fds,fds[i]);
                                                        printf("one client over\n");
                                                }
                                                else
                                                {
                                                printf("buff(c=%d)=%s\n",fds[i],buff);
                                                send(fds[i],"ok",2,0);
                                                }
                                        }
                                }
                        }

                }

        }
}

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

        struct sockaddr_in saddr;
        memset(&saddr,0,sizeof(saddr));
        saddr.sin_family=AF_INET;
        saddr.sin_port=htons(6000);
        saddr.sin_addr.s_addr=inet_addr("127.0.0.1");

        int res = bind(sockfd,(struct sockaddr*)&saddr,sizeof(saddr));
        if(res == -1)
        {
                return -1;
        }
        res = listen(sockfd,5);
        if(res == -1)
        {
                return -1;
        }
        return sockfd;
}

2.select方法的应用-使用select方法实现客户端并发处理

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

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

        struct sockaddr_in saddr;
        memset(&saddr,0,sizeof(saddr));
        saddr.sin_family=AF_INET;
        saddr.sin_port=htons(6000);
        saddr.sin_addr.s_addr=inet_addr("127.0.0.1");

        int res = connect(sockfd,(struct sockaddr*)&saddr,sizeof(saddr));
        if(res == -1)
        {
                return -1;
        }
        while(1)
        {
                printf("input:\n");
                char buff[128]={0};
                fgets(buff,127,stdin);//从键盘获取数据

                if(strncmp(buff,"end",3) == 0)
                {
                        break;
                }

                send(sockfd,buff,strlen(buff)-1,0);//把键盘上接收到的数据发送给服务器

                memset(buff,0,128);
                recv(sockfd,buff,127,0);//将服务器返回的打印出来
                printf("buff=%s\n",buff);

        }
        close(sockfd);
}

2.poll方法

int poll(struct pollfd *fds,nfds_t nfds,int timeout);
//poll系统调用成功后返回就绪文件描述符的总数，超时返回0，失败返回-1

服务器端代码

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

#define MAXFD 10

void fds_init(struct pollfd fds[])
{
        int i=0;
        for(;i<MAXFD;++i)
        {
                fds[i].fd = -1;
                fds[i].events = 0;//注册的事件
                fds[i].revents = 0;//内核反馈给我们的事件
        }
}
void fds_add(struct pollfd fds[],int fd)
{
//在此代码中，我们只关注读事件因此将其写死
        int i=0;
        for(;i<MAXFD;++i)
        {
                if(fds[i].fd == -1)
                {
                        fds[i].fd = fd;
                        fds[i].events = POLLIN; //读事件r           
                        fds[i].revents = 0;
                        break;
                }
        }
}
void fds_del(struct pollfd fds[],int fd)
{
        int i=0;
        for(;i<MAXFD;++i)
        {
                if(fds[i].fd == fd)
                {
                        fds[i].fd = -1;
                        fds[i].events = 0;
                        fds[i].revents = 0;
                }
        }
}


int create_socket();
int main()
{
        int sockfd = create_socket();
        assert(sockfd != -1);
        //由于是对应多个客户端，因此我们要把文件描述符收集起来
        //之后再来检测有没有我们关心的事件产生

        struct  pollfd fds[MAXFD]; //将文件描述符存入数组中
        fds_init(fds);

        fds_add(fds,sockfd);

        while(1)
        {
                int n=poll(fds,MAXFD,5000);//时间单位是ms，会阻塞住，直到超时或者有事件返>回
                //也可以将其写为-1，就是永久阻塞住，直到有时间返回
                if(n== -1)
                {
                        continue;
                }
                else if(n==0)
                {
                        printf("time out\n");
                        continue;
                }
                else
                {
                        //检测哪个描述符上有数据
                        int i = 0;
                        for(;i<MAXFD;++i)
                        {
                                if(fds[i].fd == -1)
                                {
                                        continue;
                                }
                                if(fds[i].revents&POLLIN)//判断返回的事件中有没有pollin读>事件
                                {
                                        if(fds[i].fd == sockfd)
                                        {
                                                //accept
                                                struct sockaddr_in caddr;
                                                int len = sizeof(caddr);
                                                int c=accept(sockfd,(struct sockaddr*)&caddr,&len);

                                                if(c<0)
                                                {
                                                        continue;
                                                }
                                              printf("accept c=%d\n",c);
                                                fds_add(fds,c);
                                        }
                                        else
                                        {
                                                //recv
                                                char buff[128]={0};
                                                int num =recv(fds[i].fd,buff,127,0);
                                                if(num<=0)
                                                {
                                                        close(fds[i].fd);
                                                        fds_del(fds,fds[i].fd);
                                                        printf("client close\n");
                                                        continue;
                                                }
                                                printf("buff(%d)=%s\n",fds[i].fd,buff);
                                                send(fds[i].fd,"ok",2,0);

                                        }
                                }
                                //if(fds[i].revents&POLLOUT)//判断是否有写事件
                        }
                }

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

        struct sockaddr_in saddr;
        memset(&saddr,0,sizeof(saddr));
        saddr.sin_family=AF_INET;
        saddr.sin_port=htons(6000);
        saddr.sin_addr.s_addr=inet_addr("127.0.0.1");

        int res = bind(sockfd,(struct sockaddr*)&saddr,sizeof(saddr));
        if(res == -1)
        {
                return -1;
        }
        res = listen(sockfd,5);
        if(res == -1)
        {
                return -1;
        }
        return sockfd;
}

客户端代码与之前的一模一样，略

3.epoll

在这里插入图片描述在这里插入图片描述

1.epoll各接口的使用

在这里插入图片描述
在这里插入图片描述在这里插入图片描述

2.LT与ET模式

2.1.LT模式下的服务器代码（默认情况下是LT模式）
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<fcntl.h>
#include<assert.h>
#include<unistd.h>
#include<arpa/inet.h>
#include<sys/epoll.h>

#define MAXFD 10
//此时只关注读事件，因此不传入事件
void epoll_add(int epfd ,int fd)
{
        struct epoll_event ev;
        ev.events = EPOLLIN;//read
        ev.data.fd=fd;

        if(epoll_ctl(epfd,EPOLL_CTL_ADD,fd,&ev) == -1)
        {
                perror("epoll ctl add err");
        }
}
void epoll_del(int epfd,int fd)
{
        if(epoll_ctl(epfd,EPOLL_CTL_DEL,fd,NULL) == -1)
        {
                perror("epoll ctl del err");
        }
}


int create_socket();
int main()
{
        int sockfd = create_socket();
        assert(sockfd != -1);
        //由于是对应多个客户端，因此我们要把文件描述符收集起来
        //之后再来检测有没有我们关心的事件产生

        int epfd = epoll_create(MAXFD);
        assert(epfd!=-1);

        epoll_add(epfd,sockfd);
        //往内核实现表中添加元素，检测是否有数据
        //获取就绪描述符

        struct epoll_event evs[MAXFD];

        while(1)
        {
                int n=epoll_wait(epfd,evs,MAXFD,5000);//5000ms=5s
                if(n==-1)
                {
                        perror("epoll wait err\n");
                }
                else if(n==0)
                {
                        printf("time out\n");
                }
                else
                {
                        int i=0;
                        for(;i<n;++i)
                        {
                                int fd=evs[i].data.fd;

                                if(evs[i].events&EPOLLIN)
                                {
                                        //描述符不同处理方法不同
                                        if(fd==sockfd)
                                        {
                                                //accept
                                                struct sockaddr_in caddr;
                                                int len = sizeof(caddr);
                                                int c=accept(sockfd,(struct sockaddr*)&caddr,&len);

                                                if(c<0)
                                                {
                                                        continue;
                                                }
                                                printf("accept c=%d\n",c);
                                                epoll_add(epfd,c);
                                        }
                                        else
                                        {
                                                //recv
                                                char buff[128]={0};
                                                int num =recv(fd,buff,127,0);
                                                if(num<=0)
                                                {
                                                        epoll_del(epfd,fd);
                                                        close(fd);
                                                        printf("client close\n");
                                                        continue;
                                                }
                                                printf("buff(%d)=%s\n",fd,buff);
                                                send(fd,"ok",2,0);
                                        }
                                }
                        }
                }
        }

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

        struct sockaddr_in saddr;
        memset(&saddr,0,sizeof(saddr));
        saddr.sin_family=AF_INET;
        saddr.sin_port=htons(6000);
        saddr.sin_addr.s_addr=inet_addr("127.0.0.1");

        int res = bind(sockfd,(struct sockaddr*)&saddr,sizeof(saddr));
        if(res == -1)
        {
                return -1;
        }
        res = listen(sockfd,5);
        if(res == -1)
        {
                return -1;
        }
        return sockfd;
}
2.2.ET模式

Q：如何开启ET模式
A：在添加事件时或一个EPOLLET即：

void epoll_add(int epfd ,int fd)
{
        struct epoll_event ev;
        ev.events = EPOLLIN | EPOLLET;///在这里！！！！
        ev.data.fd=fd;

        if(epoll_ctl(epfd,EPOLL_CTL_ADD,fd,&ev) == -1)
        {
                perror("epoll ctl add err");
        }
}
2.2.1.ET和LT的区别

在这里插入图片描述

2.2.2.ET模式下的服务器代码（只提醒一次，因此要在收到一次提醒后，把所有数据读完）

accept方法也需要循环读取，此代码并未修改这个部分
ET模式下会产生矛盾：
1.收到提示后，如果只读一次，如果没读完，不会再提醒。
2.如果第一次读完后再去读第二次，如果没数据了，recv会阻塞。

因此将思路设置为：
1.将描述符设置为非阻塞模式。
2.循环读取数据，直到数据读取完成

步骤：
1.在添加事件类型时，添加上EPOLLET；（开启ET模式）
2.描述符需要设置为非阻塞模式（fcntl方法）
3.在io函数返回后，提醒我们描述符上有读事件产生。采用循环处理，直到数据被读完

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


#define MAXFD 10
/！！！！！！！！！！！！！///
//1.将描述符设为非阻塞//
void setnonblock(int fd)
{
        int oldfl = fcntl(fd,F_GETFL);
        int newfl = oldfl | O_NONBLOCK;

        if(fcntl(fd,F_SETFL,newfl) == -1)
        {
                perror("fcntl error\n");
        }
}
//！！！！！！！！//

//此时只关注读事件，因此不传入事件
void epoll_add(int epfd ,int fd)
{
        struct epoll_event ev;
        ev.events = EPOLLIN;//read
        ev.data.fd=fd;
        //每添加一个描述符，都将其设为非阻塞模式！！！！        
        setnonblock(fd);
        /！！！！！！！！！！！！

        if(epoll_ctl(epfd,EPOLL_CTL_ADD,fd,&ev) == -1)
        {
                perror("epoll ctl add err");
        }
}
void epoll_del(int epfd,int fd)
{
        if(epoll_ctl(epfd,EPOLL_CTL_DEL,fd,NULL) == -1)
        {
                perror("epoll ctl del err");
        }
}


int create_socket();
int main()
{
        int sockfd = create_socket();
        assert(sockfd != -1);
        //由于是对应多个客户端，因此我们要把文件描述符收集起来
        //之后再来检测有没有我们关心的事件产生

        int epfd = epoll_create(MAXFD);
        assert(epfd!=-1);

        epoll_add(epfd,sockfd);
        //往内核实现表中添加元素，检测是否有数据
        //获取就绪描述符

        struct epoll_event evs[MAXFD];

        while(1)
        {
                int n=epoll_wait(epfd,evs,MAXFD,5000);//5000ms=5s
                if(n==-1)
                {
                        perror("epoll wait err\n");
                }
                else if(n==0)
                {
                        printf("time out\n");
                }
                else
                {
                        int i=0;
                        for(;i<n;++i)
                        {
                                int fd=evs[i].data.fd;

                                if(evs[i].events&EPOLLIN)
                                {
                                        //描述符不同处理方法不同
                                        if(fd==sockfd)
                                        {
                                                //accept
                                                struct sockaddr_in caddr;
                                                int len = sizeof(caddr);
                                                int c=accept(sockfd,(struct sockaddr*)&caddr,&len);

                                                if(c<0)
                                                {
                                                        continue;
                                                }
                                                printf("accept c=%d\n",c);
                                                epoll_add(epfd,c);
                                        }
                                        else
                                        {
                                                //recv
                                                //修改对于连接套接字的处理方式（循环读取）
                                               while(1)
                                                {
                                                        char buff[128]={0};
                                                        int num =recv(fd,buff,1,0);
                                                        if(num == -1)
                                                        {
                                                                if(errno != EAGAIN && errno != EWOULDBLOCK)
                                                                {
                                                                        perror("recv err");
                                                                }
                                                                else //这种情况只是因为数据读完了，因此回复ok（非阻塞情况下，缓冲区中没有数据）
                                                                {
                                                                        send(fd,"ok",2,0);
                                                                }
                                                                break;
                                                        }
                                                        else if(num==0)
                                                        {
                                                                epoll_del(epfd,fd);
                                                                close(fd);
                                                                printf("client close\n");
                                                                break;
                                                        }
                                                        else
                                                        {
                                                                printf("rec:%s\n",buff);
                                                        }
                                                }
                                        }
                                }
                        }
                }
        }

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

        struct sockaddr_in saddr;
        memset(&saddr,0,sizeof(saddr));
        saddr.sin_family=AF_INET;
        saddr.sin_port=htons(6000);
        saddr.sin_addr.s_addr=inet_addr("127.0.0.1");

        int res = bind(sockfd,(struct sockaddr*)&saddr,sizeof(saddr));
        if(res == -1)
        {
                return -1;
        }
        res = listen(sockfd,5);
        if(res == -1)
        {
                return -1;
        }
        return sockfd;
}
lijing-blog
关注
专栏目录
Linux下I/O复用模型
WeinKee的博客
06-27 334
以下内容引述至《Linux/Unix系统编程手册》 整体概览 常见的程序使用的I/O模型都是单个进程每次只在一个文件描述符上执行I/O操作，每次I/O系统调用会阻塞直到完成数据传输。 对于许多应用来说，传统的阻塞式I/O模型已经足够了，但这不代表所有的应用都能得到满足。 如果可能的话，以非阻塞的方式检查文件描述符上是否可进行I/O操作 同时检查多个文件描述符，看它们中的任何一个是否可以执行I/O操作 满足这些技术需求的方案是： 非阻塞式I/O 和 多进程或多线程技术 非阻塞式I/O可以让我们周期性地检查
Linux下常见I/O模型及其相关基础知识
bulangman277的博客
04-04 1262
自从接触Linux服务器开发到现在，对于阻塞、非阻塞、同步、异步这些概念其实还是感觉挺模糊的，查了很多资料，看了很多博客和文章，现在从个人理解的角度来总结一下这些概念的区别，既方便自己的复习，也希望可以给看到这篇博客的伙伴们一个相对正确的指引。 I/O复用是什么 I/O多路复用就是一种使得程序可以同时监听多个文件描述符的技术，能够提高程序的性能。其中的I/O是指socket对读写缓冲区（内存）的读写操作，不是简单意义上的cin和cout。在Linux下能够实现I/O多路复用的系统调用方法主要有：select
Linux网络编程——I/O复用之select详解
每天积累一点点
06-15 5893
一、I/O复用概述 I/O复用概念： 解决进程或线程阻塞到某个 I/O 系统调用而出现的技术，使进程不阻塞于某个特定的 I/O 系统调 I/O复用使用的场合： 1.当客户处理多个描述符（通常是交互式输入、网络套接字）时，必须使用I/O复用。 2.tcp服务器既要处理监听套接字，又要处理已连接套接字，一般要使用I/O复用。 3.如果一个服务器既要处
Linux五 ——I/O复用
weixin_43662553的博客
05-31 598
Linux五 ——I/O复用
（linux）i/o复用
qq_54395977的博客
11-07 881
1、i/o复用概述： 通过一种机制，让单个进程可以监视多个文件描述符，一旦某个描述符就绪，能够通知程序进行相应的读写操作 i/o复用是一种非阻塞机制，通过循环的请求，但循环请求的对象不单一。一旦满足就进行相应的操作。 ...
Linux下的I/O复用
gx1589969的博客
03-05 228
Linux下的IO复用系统调用主要有select、poll、epoll, select select能监听的文件描述符个数受限于FD_SETSIZE,一般为1024，单纯改变进程打开的文件描述符个数并不能改变select监听文件个数 解决1024以下客户端时使用select是很合适的，但如果链接客户端过多，select采用的是轮询模型，会大大降低服务器响应效率，不应在select上投入更多精...
Linux I/O多路复用详解及实例
09-15
Linux I/O多路复用是一种高效的编程模型，它允许单个进程同时监视多个I/O事件，从而提高了系统的并发处理能力。在Linux中，I/O多路复用主要有三种实现方式：`select`、`poll`和`epoll`。这些机制都用于解决传统阻塞I...
浅谈Linux 网络 I/O 模型简介（图文）
09-15
根据UNIX网络编程的分类，Linux提供了五种I/O模型，分别是阻塞I/O、非阻塞I/O、I/O复用模型、信号驱动I/O以及异步I/O。 1. **阻塞I/O模型**： 在这个模型中，进程调用如`recvfrom`这样的系统调用时，会一直等待...
IO模型-I/O复用模型
weixin_44614002的博客
07-17 1116
IO复用模型一般为异步阻塞IO，但select、poll、epoll本质上还是同步IO（都是需要读写事件就绪后再进行读写，而且整个读写的过程是阻塞的），真正意义上的异步IO是不需要负责进行读写操作的。epoll使用一个文件描述符管理多个描述符，将用户关系的文件描述符的事件存放到内核的一个事件表中，这样在用户空间和内核空间的copy只需要一次。​缺点单个进程能够监视的文件描述符的数量存在最大限制，在Linux上为1024，可以通过修改宏定义甚至重新编译内核的方式提升这一限制，但这样会造成效率的降低。.....
Linux || I/O复用
LQEmptycity的博客
11-20 216
IO复用：同时监听多个文件描述符 select：同时监听多个文件描述符，最多1024个，读，写，异常，集合 内核：轮询方式 时间复杂度：O(n) poll：支持比select更多的文件描述符， 内核：轮询方式 时间复杂度：O(n) select与poll的缺点： - 找到就绪描述符 需要遍历所有描述符O(n) - 内核中是轮询的方式 - 每次都需要向内核传递描述符和事件 epoll：解决select与poll的缺陷 select：就绪描述符数目，不知道具体是谁，数目不多的情况下 读、写、异常事件
linux常见的I/O复用技术汇总-select、poll、epoll
最新发布
深耕嵌入式领用多年， 致力于分享嵌入式领域技术!
05-26 136
常见的I/O复用技术详解
Linux 系统 select I/O 复用
HarvestWu的博客
06-22 362
       I/O多路复用技术通过把多个I/O的阻塞复用到同一个select的阻塞上，从而使得系统在单线程的情况下可以同时处理多个客户端请求。与传统的多线程/多进程模型比，I/O多路复用的最大优势是系统开销小，系统不需要创建新的额外进程或者线程，也不需要维护这些进程和线程的运行，降底了系统的维护工作量，节省了系统资源。请根据实际情况设置IP和端口号Server端代码：#include &lt;s...
Linux网络编程之I/O复用
Aaron的专栏
04-24 2357
Linux编程之IO多路复用(I/O Multiplexing) 程序设计过程中有时候会对多个输入进行操作，例如标准输入或者多个socket。那么如果在对某个进行处理的时候阻塞住的话，另外的输入进来的话会得不到及时的处理。（比如客户端程序调用fgets／cin的时候会阻塞在标准输入的地方，此时如果有监听的socket请求连接的话是得不到及时处理的）。 对于这种情况就需要当内核发现我们指定的IO
linux - I/O复用:select
饱食而遨游，泛若不系之舟
12-01 218
I/O多路复用： 在多个网络连接中，共用少数几个进程或线程。 支持IO多路复用的进程，需要先通知内核进行监控，等待内核监控到指定的一个或者多个I/O条件就绪（输入准备好被读取，或者文件描述符已经能承受更多的输出），它就通知进程。 5种I/O模型基本区别 输入操作包括两个阶段： 等待数据准备好 从内核向进程复制数据 对于一个套接字上的输入操作，1. 等待数据从网络中到达。当所有等待分组到达时，它被复制到内核中的某个缓冲区。2. 将数据从内核缓冲区复制到应用进程缓冲区。 阻塞式I/O模型 阻塞式I/O模型(
Linux系统编程---I/O多路复用
qq_41683305的博客
04-28 1456
文章目录1 什么是IO多路复用2 解决什么问题说在前面I/O模型阻塞I/O非阻塞I/OIO多路复用信号驱动IO异步IO3 目前有哪些IO多路复用的方案解决方案总览常见软件的IO多路复用方案4 具体怎么用selectpollepolllevel-triggered and edge-triggered状态变化通知(edge-triggered)模式下的epoll5 不同IO多路复用方案优缺点poll vs selectepoll vs poll&select 1 什么是IO多路复用 一句话解释：单线程
Linux下的5种I/O模型与3组I/O复用
pythonxxoo的博客
02-04 483
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 引言 上一篇文章中介绍了一些无缓冲文件I/O函数，但应该什么时机调用这些函数，调用这些I/O函数时进程和内核的行为如何，如何高效率地实现I/O？这篇文章就来谈一谈Linux下的5种I/O模型，以及高性能服务器编程中常用的I/O复用，为后面实现精简版本的高性能服务器做铺垫。 Li
linux io复用方法,Linux下的IO复用 - LinuxCPlusPlus的个人空间 - OSCHINA - 中文开源技术交流社区...
weixin_39892800的博客
05-13 84
IO复用时用来干什么的？IO复用可以使得程序监听多个文件描述符。IO复用本身是阻塞的，并且如果无特殊的控制，会顺序地处理各个文件描述符。这使得程序看起来像是串行的。要实现并发则需要引入多进程或多线程。常用的IO复用有select、epoll、pollselect？在指定时间内，用于监听用户感兴趣的文件描述符集合上的读写异常事件。int select(int 监听的文件描述符总数,fd_set*用于...
Linux的三种I/O复用方式——poll
Kevinonlie的博客
04-24 587
I/O复用函数 select poll epoll<Linux的独有的I/O复用> 接下来我们分三次进行介绍I/O复用 poll poll的原型是 int poll (struct pollfd *fds,int nfds,int timeout); 比起select更加简洁了一些，事件不再由内核在线修改，而是存入系统提供的结构体中，将文件描述符和从内核拷贝而来的改变数据划分开，不需...
Linux I/O 复用：阻塞与非阻塞模式探索
"该资源是一份关于信息安全与产品开发实践的课件，主要探讨了阻塞模式和多路I/O复用的并发服务器模型。内容包括对多进程、多线程并发服务器模型的问题分析，以及如何通过非阻塞方式和I/O多路复用技术来改进并发性能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值