linux网络编程---IO多路复用

最新推荐文章于 2024-09-09 20:05:56 发布
最新推荐文章于 2024-09-09 20:05:56 发布
阅读量476 收藏 2
点赞数
分类专栏： C++ linux 文章标签： c++ linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37042030/article/details/124366194
版权

IO模型:

阻塞等待模型（BIO)：

1）优点：不占用CPU时间片，阻塞时，cpu时间片交给别人，缺点：但同时只能处理同一个操作。

2）可以使用多线程/多进程实现并发处理多个客户端请求，每个线程对应一个客户端，线程里进行读写操作，主线程则可以继续运行监听客户端。  (但每个线程里 其实也会存在阻塞问题）

while(1)

{

        accept(lfd,...);  (blocking)

        create thread->read/write; (blocking)

}

但是缺点：a.线程/进程会消耗资源，b.调度线程/进程会消耗CPU资源。

非阻塞IO模型：（忙轮询 NIO）

1）accept read write 非阻塞，没读到继续往下执行，不断轮询。优点：提高了程序执行效率。缺点：需要占用更多的CPU和系统资源。

while(1)

{

        accept(lfd,...)；

       读写现有的已accept的fd, 遍历轮询read/write;  ->浪费系统资源。

}

2）使用IO多路复用技术来改进。

IO多路复用：

使程序能够同时监听多个文件描述符（监听内核缓冲区），提高程序性能。（可以判断同时有多少客户端来和我通信）。(告诉内核要监听的fd集合，而非自己对所有fd轮询read write).

select/poll

1.select

但是select poll内核不会告诉使用者具体是哪些快递到了，只会告诉总数。底层使用二进制位表示某个fd有无数据，相比read write判断有无数据效率更高。

1. 将要监听的fd添加到fd列表。

2. 调用select（），内核会监听列表中的fd,当有某个/多个fd进行IO操作，函数返回。 （阻塞函数）

3. 返回时，会告诉进程有多少fd要进行IO操作。

select（）将我们想监听的读写异常fd交给内核去检测。 （fd集合最大1024个）

对fd集合二进制位的操作

 工作过程

 readfds等是指针，指明要检测的fd的集合，如0010.内核检测后会将其改变为检测到的结果。如第二个有数据可以读，第3个没有，则修改为0100；

缺点：

1）每次调用select，要将fds从用户态拷贝到内核态。fds很大时开销会很大。

2）每次调用select，内核要对fds进行遍历。fds很大时开销会很大。再拷贝回用户态，也开销很大。 用户态又要遍历判断是哪些fd发生了改变。 O(n)

3）select支持的fd最大数量1024，（fd_set 数组大小128字节，1024位）太小（最多支持1024客户端）。

4）fd集合不能重用（被内核修改了），为了下次检测每次都需要重置。

代码实现： 

client.cpp

#include <iostream>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <cstring>
using namespace std;

int main()
{
    
    int fd=socket(AF_INET,SOCK_STREAM,0);
    if(fd==-1)
    {
        perror("socket:");
        exit(-1);
    }
    sockaddr_in serveraddr;
    inet_pton(AF_INET,"127.0.0.1",&serveraddr.sin_addr.s_addr);
    serveraddr.sin_port=htons(9090);
    serveraddr.sin_family=AF_INET;
    int ret=connect(fd,(sockaddr*)&serveraddr,sizeof(serveraddr));
    if(ret==-1)
    {
        perror("connect: ");
        exit(-1);
    }

    int n=0;
    while(1)
    {
        if(n<9)    
            n++;
        else 
        n=0;
        
        
        char sendBuf[50]="hello,this is ";
        sendBuf[14]=(char)(n+'0');
        
        write(fd,sendBuf,strlen(sendBuf));
        
        char readBuf[80]="client received ";
        
        int len=read(fd,sendBuf,sizeof(sendBuf));
        if(len==0)
        {
            cout<<"server closed\n";
            break;
        }
        else if(len==-1)
        {
            perror("read: ");
            exit(-1);
        }
        strcat(readBuf,sendBuf);
        cout<<readBuf<<endl;
       sleep(2);
    }
    close(fd);

}

select.cpp

#include <sys/types.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <sys/select.h>
#include <unistd.h>
#include <string.h>
#include <iostream>

int main()
{
    int lfd=socket(PF_INET,SOCK_STREAM,0);
    struct sockaddr_in saddr;
    saddr.sin_port=htons(9090);
    saddr.sin_family=AF_INET;
    saddr.sin_addr.s_addr=INADDR_ANY;

    int ret=bind(lfd,(sockaddr*)&saddr,sizeof(saddr));
    if(ret==-1)
    {
        perror("bind");
        exit(-1);
    }
    ret=listen(lfd,8);
    if(ret==-1)
    {
        perror("listen");
        exit(-1);
    }

    fd_set rdset,tmp_set;//要检测的fd集合
    FD_ZERO(&rdset);//初始化
    FD_SET(lfd,&rdset);//添加要检测的fd
    int maxfd=lfd;

    while(1)
    {
        tmp_set=rdset; //使内核修改fd不影响我们要检测的fd
        //让内核检测fd集合 永久阻塞，直到有变化
        int ret=select(maxfd+1,&tmp_set,nullptr,nullptr,nullptr);
        if(ret==-1)
        {
            perror("select");
            exit(-1);
        }
        //检测到有fd对应的缓冲区的数据发生了改变。
        
        //判断监听的lfd 是否有客户端要连接
        if(FD_ISSET(lfd,&tmp_set))
        {
            sockaddr_in clientaddr;
            int len=sizeof(clientaddr);
            int cfd=accept(lfd,(sockaddr*)&clientaddr,(socklen_t*)&len);

            //将通信fd加入rdset。
            FD_SET(cfd,&rdset);
            maxfd = maxfd>cfd ? maxfd : cfd;           
        }
        //遍历其他的cfd，判断是否有数据读 从监听的lfd+1开始遍历。
        for(int i=lfd+1;i<maxfd+1;i++)
        {
            if(FD_ISSET(i,&tmp_set))
            {
                char buf[1024]={0};
                int len=read(i,buf,sizeof(buf));
                if(len==-1)
                {
                    perror("read");
                    exit(-1);
                }   
                else if(len==0)
                {
                    printf("%d client closed\n",i); //客户端断开，将其从fd集合删去
                    close(i);
                    FD_CLR(i,&rdset);
                }
                else
                {
                    std::cout<<"read buf= "<<buf<<" from "<<i<<std::endl;
                    write(i,buf,strlen(buf)+1);
                }

            }
        }
    }
    close(lfd);

}

2.poll  

通过events和revents,内核修改时会修改revents，使得events可以重用。并且没有1024的限制。

 

 

 缺点：

1）基本和select一致，但是没有1024最大连接数的限制。（基于链表存储）

2）events集合可重用。  

3）水平触发。如果报告了fd后，没有被处理，那么下次poll时会再次报告该fd。

代码实现

#include <sys/types.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <sys/poll.h>
#include <unistd.h>
#include <string.h>
#include <iostream>

int main()
{
    int lfd=socket(PF_INET,SOCK_STREAM,0);
    struct sockaddr_in saddr;
    saddr.sin_port=htons(9090);
    saddr.sin_family=AF_INET;
    saddr.sin_addr.s_addr=INADDR_ANY;

    int ret=bind(lfd,(sockaddr*)&saddr,sizeof(saddr));
    if(ret==-1)
    {
        perror("bind");
        exit(-1);
    }
    ret=listen(lfd,8);
    if(ret==-1)
    {
        perror("listen");
        exit(-1);
    }

    pollfd fdset[2048]; //要监听的fd集合结构体
    for(int i=0;i<2048;i++)
    {
        fdset[i].fd=-1;
        fdset[i].events=POLLIN;//检测读事件
    }
    fdset[0].fd=lfd; //将监听lfd加入集合。

    int maxfd=0;

    while(1)
    {
       
        //让内核检测fd集合 阻塞，直到有变化
        int ret=poll(fdset,maxfd+1,-1);
        if(ret==-1)
        {
            perror("poll");
            exit(-1);
        }
        //检测到有fd对应的缓冲区的数据发生了改变。
        
        //判断监听的lfd 是否有客户端要连接
        if(fdset[0].revents & POLLIN)
        {
            sockaddr_in clientaddr;
            int len=sizeof(clientaddr);
            int cfd=accept(lfd,(sockaddr*)&clientaddr,(socklen_t*)&len);

            //将通信fd加入rdset。  遍历是为了重用在连接过程中已使用又断开的fd位置。
            for(int i=1;i<2048;i++)
            {
                if(fdset[i].fd==-1)
                {
                    fdset[i].fd=cfd;
                    fdset[i].events=POLLIN;
                    maxfd = maxfd>i ? maxfd : i;  //更新最大的fd索引
                    break;
                }
            }
                    
        }
        //遍历其他的cfd，判断是否有数据读 从监听的lfd+1开始遍历。
        for(int i=1;i<maxfd+1;i++)
        {
            if(fdset[i].revents&POLLIN)
            {
                char buf[1024]={0};
                int len=read(fdset[i].fd,buf,sizeof(buf));
                if(len==-1)
                {
                    perror("read");
                    exit(-1);
                }   
                else if(len==0)
                {
                    printf("%d client closed\n",fdset[i].fd); //客户端断开，将其从fd集合删去
                    close(fdset[i].fd);
                    fdset[i].fd=-1;
                }
                else
                {
                    std::cout<<"read buf= "<<buf<<" from "<<fdset[i].fd<<std::endl;
                    write(fdset[i].fd,buf,strlen(buf)+1);
                }

            }
        }
    }
    close(lfd);

}

epoll

 用epoll_create直接在内核创建一个epoll实例eventpoll，通过epoll_create返回的fd控制这个实例。减少select poll将fd集合从用户态拷贝到内核态的切换。

 rbr 记录需要检测的fd,  底层红黑树，遍历效率非常快。

 rdlist 就绪fd的链表。可以告诉用户具体改变的fd。

epoll_ctl 管理epoll实例

epoll_data中的fd可以在遍历变化的fd作判断时用到

 

 

 代码实现

#include <sys/types.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <sys/epoll.h>
#include <unistd.h>
#include <string.h>
#include <iostream>

int main()
{
    int lfd=socket(PF_INET,SOCK_STREAM,0);
    struct sockaddr_in saddr;
    saddr.sin_port=htons(9090);
    saddr.sin_family=AF_INET;
    saddr.sin_addr.s_addr=INADDR_ANY;

    int ret=bind(lfd,(sockaddr*)&saddr,sizeof(saddr));
    if(ret==-1)
    {
        perror("bind");
        exit(-1);
    }
    ret=listen(lfd,8);
    if(ret==-1)
    {
        perror("listen");
        exit(-1);
    }

    //创建eventpoll实例 参数>0就可以
    int epfd=epoll_create(100);

    //将监听Lfd相关信息加入epfd实例
    epoll_event epev;
    epev.events=EPOLLIN;
    epev.data.fd=lfd;
    epoll_ctl(epfd,EPOLL_CTL_ADD,lfd,&epev);

    //被监听后，发生改变的fd集合
    epoll_event epevs[1024];

    while(1)
    {
        //让内核检测epev实例 阻塞，直到有变化
        int ret=epoll_wait(epfd,epevs,1024,-1);
        
        if(ret==-1)
        {
            perror("epoll_wait");
            exit(-1);
        }
        //检测到有ret个fd对应的缓冲区的数据发生了改变。
        printf("ret = %d\n",ret);

        
        
        for(int i=0;i<ret;i++)
        {
            //判断监听的lfd 是否有客户端要连接  这里就用到了epoll_data中的fd
            if(epevs[i].data.fd==lfd)
            {
                sockaddr_in clientaddr;
                int len=sizeof(clientaddr);
                int cfd=accept(lfd,(sockaddr*)&clientaddr,(socklen_t*)&len);
                epev.events=EPOLLIN;
                epev.data.fd=cfd;
                epoll_ctl(epfd,EPOLL_CTL_ADD,cfd,&epev);    
            }
            else //cfd 有数据到达，需要通信
            {
              //  if(epev[i].data.fd & EPOLLOUT)
               // {
                //    continue;
                //}
                //有数据可读
                char buf[1024]={0};
                int len=read(epevs[i].data.fd,buf,sizeof(buf));
                if(len==-1)
                {
                    perror("read");
                    exit(-1);
                }   
                else if(len==0)
                {
                    printf("%d client closed\n",epevs[i].data.fd); //客户端断开，将其从fd集合删去
                    close(epevs[i].data.fd);
                    epoll_ctl(epfd,EPOLL_CTL_DEL,epevs[i].data.fd,nullptr);
                }
                else
                {
                    std::cout<<"read buf= "<<buf<<" from "<<epevs[i].data.fd<<std::endl;
                    write(epevs[i].data.fd,buf,strlen(buf)+1);
                }

            }
        }
    }
    close(lfd);
    close(epfd); //关闭epoll实例

}

epoll的工作模式：

1) LT (默认)

水平触发，支持阻塞和非阻塞socket。内核通知用户某fd就绪后，用户未操作或只操作了一部分数据，下次epoll_wait仍会通知用户该fd就绪，直到用户操作完缓冲区数据，fd变为未就绪。

2)ET

边沿触发，只支持非阻塞socket。内核通知用户某fd就绪后，用户未操作或只操作了一部分数据，下次epoll_wait不会通知用户该fd就绪，直到用户操作后使fd变为非就绪，下次fd再次就绪才会通知用户。

所以在用户操作该fd时，需要循环读取完其所有数据，否则数据未读完下次不被通知就会一直处理不到。在读取过程中，为了不断read时不会阻塞，ET只支持非阻塞SOCKET。

优点：减少了epoll事件被重复触发的次数，效率高于LT。

 

#include <iostream>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <cstring>
using namespace std;

int main()
{
    
    int fd=socket(AF_INET,SOCK_STREAM,0);
    if(fd==-1)
    {
        perror("socket:");
        exit(-1);
    }
    sockaddr_in serveraddr;
    inet_pton(AF_INET,"127.0.0.1",&serveraddr.sin_addr.s_addr);
    serveraddr.sin_port=htons(9090);
    serveraddr.sin_family=AF_INET;
    int ret=connect(fd,(sockaddr*)&serveraddr,sizeof(serveraddr));
    if(ret==-1)
    {
        perror("connect: ");
        exit(-1);
    }

    int n=0;
    while(1)
    {
        // if(n<9)    
        //     n++;
        // else 
        // n=0;
        
        
        // char sendBuf[50]="hello,this is ";
        // sendBuf[14]=(char)(n+'0');
        char sendBuf[1024]={0};
        fgets(sendBuf,sizeof(sendBuf),stdin);
        
        write(fd,sendBuf,strlen(sendBuf)+1);
        
        char readBuf[80]="client received ";
        
        int len=read(fd,sendBuf,sizeof(sendBuf));
        if(len==0)
        {
            cout<<"server closed\n";
            break;
        }
        else if(len==-1)
        {
            perror("read: ");
            exit(-1);
        }
        strcat(readBuf,sendBuf);
        cout<<readBuf<<endl;
        
    }
    close(fd);

}
#include <sys/types.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <sys/epoll.h>
#include <unistd.h>
#include <string.h>
#include <iostream>
#include <fcntl.h>
#include <errno.h>
int main()
{
    int lfd=socket(PF_INET,SOCK_STREAM,0);
    struct sockaddr_in saddr;
    saddr.sin_port=htons(9090);
    saddr.sin_family=AF_INET;
    saddr.sin_addr.s_addr=INADDR_ANY;

    int ret=bind(lfd,(sockaddr*)&saddr,sizeof(saddr));
    if(ret==-1)
    {
        perror("bind");
        exit(-1);
    }
    ret=listen(lfd,8);
    if(ret==-1)
    {
        perror("listen");
        exit(-1);
    }

    //创建eventpoll实例 参数>0就可以
    int epfd=epoll_create(100);

    //将监听Lfd相关信息加入epfd实例
    epoll_event epev;
    epev.events=EPOLLIN;
    epev.data.fd=lfd;
    epoll_ctl(epfd,EPOLL_CTL_ADD,lfd,&epev);

    //被监听后，发生改变的fd集合
    epoll_event epevs[1024];

    while(1)
    {
        //让内核检测epev实例 阻塞，直到有变化
        int ret=epoll_wait(epfd,epevs,1024,-1);
        
        if(ret==-1)
        {
            perror("epoll_wait");
            exit(-1);
        }
        //检测到有ret个fd对应的缓冲区的数据发生了改变。
        printf("ret = %d\n",ret);

        
        
        for(int i=0;i<ret;i++)
        {
            //判断监听的lfd 是否有客户端要连接  这里就用到了epoll_data中的fd
            if(epevs[i].data.fd==lfd)
            {
                sockaddr_in clientaddr;
                int len=sizeof(clientaddr);
                int cfd=accept(lfd,(sockaddr*)&clientaddr,(socklen_t*)&len);
                printf("new client\n");
                //设置cfd非阻塞
                int flag=fcntl(cfd,F_GETFL);
                flag|=O_NONBLOCK;
                fcntl(cfd,F_SETFL,flag);
                 //设置ET模式
                epev.events=EPOLLIN|EPOLLET;
                epev.data.fd=cfd;
                epoll_ctl(epfd,EPOLL_CTL_ADD,cfd,&epev);    
            }
            else //cfd 有数据到达，需要通信
            {

                char buf[5]={0};
                int len=0;
                //循环读取所有数据
                while((len=read(epevs[i].data.fd,buf,sizeof(buf)))>0)
                {
                    std::cout<<"read buf= "<<buf<<" from "<<epevs[i].data.fd<<std::endl;
                    write(epevs[i].data.fd,buf,strlen(buf)+1);
                }
                if(len==-1)
                {
                    if(errno==EAGAIN) //数据读完了
                        printf("data over\n");
                    else
                    {
                        perror("read");
                        exit(-1);
                    }                 
                }   
                else if(len==0)
                {
                    printf("%d client closed\n",epevs[i].data.fd); //客户端断开，将其从fd集合删去
                    close(epevs[i].data.fd);
                    epoll_ctl(epfd,EPOLL_CTL_DEL,epevs[i].data.fd,nullptr);
                }

            }
        }
    }
    close(lfd);
    close(epfd); //关闭epoll实例

}

希望我努力一点
关注
专栏目录
Linux IO 多路复用（select、poll、epoll）
wyj613的博客
12-30 1154
Linux IO 模型 (select、poll、epoll) 1. select 详解及优缺点 2. poll 详解及优缺点 3. epoll 详解及优缺点
Linux网络编程-----IO
mutou8541的博客
08-20 911
CPU占用率低,等待资源时将任务挂起,不占用CPU资源,等到拿到资源后继续向下执行。
嵌入式Linux网络编程，I/O多路复用，阻塞I/O模式，非阻塞I/O模式fcntl()/ioctl()，多路复用I/O select()/pselect()/poll()，信号驱动I/O
m0_37542524的博客
11-20 774
文章目录1，I/O模型2，阻塞I/O 模式2.1，读阻塞（以read函数为例）2.2，写阻塞3，非阻塞模式I/O3.1，非阻塞模式的实现（fcntl()函数、ioctl() 函数）3.1.1，fcntl( )函数3.1.2，ioctl() 函数4，多路复用I/O4.1，实现多路复用 select()/poll()4.1.1，实现多路复用 select()4.1.2，另外的函数：pselect()/...
IO多路复用
m0_71459026的博客
08-28 825
一、IO多路复用（多个IO共用一个进程）(但一般只能处理耗时少的IO)步骤：创建集合->添加文件描述符到集合中->通知内核开始监测->根据返回的结果做对应的操作函数原型nfdsreadfdswritefdsexceptfdstimeoutNULL0：成功时，返回活动文件描述符数量；失败时，返回 -1。等待时间到达没有活动文件描述符，返回0；缺点:1.select监听文件描述符最大个数为1024(数组) 时间复杂度O(n)
Linux 网络编程（多路复用）
weixin_34310127的博客
06-03 117
服务器端代码 #include<stdio.h> #include<stdlib.h> #include<string.h> #include<sys/socket.h> #include<sys/types.h> #include<unistd.h> #include<...
Linux的IO多路复用
03-27 3511
博客主页：🏆看看是李XX还是李歘歘🏆 🌺每天分享一些包括但不限于计算机基础、算法等相关的知识点🌺 💗点关注不迷路，总有一些📖知识点📖是你想要的💗 ⛽️今天的内容是 Linux的IO多路复用 ⛽️💻💻💻 五种网络IO：阻塞IO、非阻塞IO、信号驱动IO、多路复用IO和异步IO，今天来聊一下多路复用IO在linux的实现。 I/O多路复用：以较少的代价来同时监听文件描述符，处理多个IO，一旦某个描述符就绪，通知程序进行相应处理，多路复用IO属于同步IO，Linux的IO...
Linux编程--IO多路复用
xinqi_1的博客
06-17 2164
IO多路复用是指通过一种机制，使得单个进程可以监控多个文件描述符的可读、可写和异常等事件。常见的IO多路复用技术包括：select、poll、epoll等。在实际应用中，IO多路复用可以提高程序的运行效率和性能，减少系统开销，降低系统资源的使用率。它广泛应用于网络编程、服务器开发、操作系统等领域，可以帮助开发人员更好地处理大量的网络连接和数据请求。
Linux IO多路复用之epoll网络编程
09-15
在Linux系统中，IO多路复用是一种高效的网络编程技术，它允许多个网络连接在同一时间进行处理，而不需要为每个连接创建单独的线程或进程。`epoll`是Linux内核提供的一种IO多路复用机制，特别适合于高并发、高性能的...
系统编程-多路IO复用
最新发布
m0_71813740的博客
09-09 1042
当有文件描述符就绪时，select 函数会返回，并告知哪些文件描述符已经准备好进行读取或写入操作。应用程序需要将需要监听的文件描述符和事件类型添加到 pollfd 数组中，然后调用 poll 函数进行监听。当有文件描述符就绪时，epoll_wait 函数会返回，并告知哪些文件描述符已经准备好进行读取或写入操作。-- 因为 selcet 函数会把没有就绪的文件描述符从集合中清除，所以当前在集合中的文件描述符不清楚。当有文件描述符就绪时，poll 函数会返回，并告知哪些文件描述符已经准备好进行读取或写入操作。
epoll-kqueue-c:IO多路复用脚本，可轻松在Mac和Linux上使用
03-20
在Linux和类Unix系统（如Mac OS X）中，`epoll` 和 `kqueue` 是两种常用的IO多路复用机制，它们允许程序同时监控多个文件描述符，从而提高系统的并发处理能力。本文将深入探讨这两种技术，并通过一个C语言编写的脚本...
Linux网络编程之多路复用I/O
y_q_m的博客
03-06 591
1 输入输出I/O模型   在UNIX/Linux下主要有4种I/O 模型 1.1 阻塞I/O 1.1.1阻塞I/O概述   阻塞I/O 模式是最普遍使用的I/O 模式，大部分程序使用的都是阻塞模式的I/O ，其最常用。   缺省情况下（默认情况下），套接字Socket() 建立后所处于的模式就是阻塞I/O 模式。前面学习的很多读写函数都是阻塞I/O，如下： 1、读操作中的read、recv、re...
Linux之IO多路复用
qq_35600620的博客
05-05 426
一、什么是IO多路复用 关于这部分内容请移步到下面的链接进行学习，本文主要介绍select，poll和epoll三种多路复用的实现。 https://www.zhihu.com/question/32163005 二、select的实现 2.1 select的原理： user space创建一张存放文件描述符的表，（该表的大小为1024个bit，受限于能打开文件个数），并且将需要监...
Linux网络编程(IO多路复用)
qq_35581213的博客
07-30 1000
IO模式中多路复用+网络编程1.基础知识介绍1.1 操作系统知识1.1.1 用户空间与内核空间1.1.2 进程切换1.1.3 进程的阻塞1.1.4 文件描述符fd1.2 IO多路复用1.2.1 阻塞IO1. 多线程/多进程2. 线程池1.2.2 IO复用1. select模型流程函数优缺点2. epoll模型函数工作模式3.对比2.代码服务端（select模型）客户端服务端（epoll模型）结果参考文献 1.基础知识介绍 1.1 操作系统知识 1.1.1 用户空间与内核空间 现在操作系统都是采用虚拟存储器
Linux ---- I/O 多路复用
Happinesspills
07-22 307
I/O多路复用使得程序能同时监听多个文件描述符，能够提高程序的性能，Linux下实现I/O多路复用的系统调用主要有select、poll和epoll。
Linux——IO多路复用
没实力的码农写的渣渣博客
07-30 206
对于监听和通信而言两者都有两个缓冲区，监听调用accept函数的时候会有读写缓冲区，通信调用read和write的时候也有读写缓冲区；在单线程的条件下是不能同时处理这三个函数的阻塞的，使用多路IO复用就可以同时检测若干个文件描述符； IO多路转接并发 使用io多路复用时是委托内核检测服务端所有文件描述符（通信和监听两类），这个检测过程会导致进程/线程的阻塞，如果检测到已经就绪的文件描述符阻塞解除，并将这些已就绪的文件描述符传出； 根据类型对传出的所有已经就绪的文件描述符进行判断，并做出不同的处理： 监听的
Linux网络编程——IO多路复用
NRWHF的博客
11-29 862
Linux网络编程——IO多路复用
【Linux系统编程】I/O多路复用
beyon_sir的博客
08-15 906
基于socket来读取和接收数据时，会触发阻塞等待，可以基于多线程、多进程来实现并发通信。但是I/O 多路复用使得程序在一个进程内能同时监听多个文件描述符，能够提高程序的性能，Linux 下实现 I/O 多路复用的系统调用主要有select、poll 和 epoll。 ...
多路复用IO： select、sys_select、do_select源码分析
RToax
11-18 844
《srsLTE源码学习：逻辑信道多路复用与MAC CE分解pdu_queue.h，pdu_queue.cc》 《select用法》 《从select函数谈及系统调用原理》 《Linux Socket C语言网络编程：Select Socket》 《Linux Socket C语言网络编程：Poll Socket》 《Linux Socket C语言网络编程：Epoll Socket》 《浅谈epoll》 《什么是epoll的水平触发与边缘触发？》 《linux-io-multiplexin.
2、Linux网络编程IO多路复用
qq_44918555的博客
07-27 432
IO多路复用的三个API,select \ poll \ epoll
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值