Linux应用--IO多路复用

最新推荐文章于 2024-08-14 16:09:08 发布
最新推荐文章于 2024-08-14 16:09:08 发布
阅读量493 收藏 6
点赞数 18
分类专栏： Linux应用 文章标签： linux 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56399733/article/details/141111342
版权

一、I/O多路复用简介

        socket通信，在Linux系统其是就是文件描述符，对应于内核中的缓冲区（包含读缓冲区与写缓冲区），实质上是对读写缓冲区的操作；多路复用，多条路复用成一条路。

        I/O多路复用使得程序能同时监听多个文件描述符，Linux下实现I/O多路复用的系统调用主要有select、poll、epoll。

        例如，有十个客户端连接，我们需要知道那个客户端发送了数据，那个客户端没有发送数据，应该怎么操作？遍历文件描述符的读缓冲区。但是不能同时知道。使用I/O复用可以同时监控多个文件描述符。

        几种常见的IO模型；操作IO实质就是看文件描述符中的读写缓冲区是否有数据。

        利用阻塞等待，来判断对应的读写缓冲区是否有数据，其优点是，不需要占用CPU时间，缺点是，同一时刻只能处理一个操作，效率较低。 

        进一步的，添加进程或者线程，可以同时处理多个操作。其优点就是可以连接多个客户端，实现并发操作。缺点是，线程或者进程会消耗资源，消耗CPU资源（进程调度）。

代码如何写？BIO模型；

1、首先创建一个socket，然后链接，监听，阻塞在accept，当有一个客户端连接的时候，进行通信，阻塞在read或者recv中，当有数据操作时，才继续执行，但是如果阻塞在accept的时候，另外在有客户端进来，就不能再accept。

2、改进采用多线程操作， 在线程中阻塞read或者recv。可以同时使得其他客户端进行连接。

根本问题就是阻塞；

非阻塞，忙轮循

        不存在阻塞技术，因为采用不停的轮循，去判断是否有客户端的连接，是否有数据的收发，不需要阻塞在那一块，但是需要不停的轮循遍历，浪费系统资源。

优点：提高程序的执行效率；

缺点：需要占用更多的CPU和资源管理；

IO多路转接技术

        内核检测数据，可以知道有没有数据到，有没有客户端进行连接，但是具体是哪一个还需要轮循遍历。 但是这个遍历不再是遍历read或者recv函数，而是另外的01效率较比之前是有所提升的。

        内核检测，不仅能检测到是否有数据到，还能告诉你是那几个数据到了。在程序中只需呀检测一次，实现多路复用为一路的。

二、select 技术

    主旨思想：

        1、构造一个关于文件描述符的列表，将要监听的文件描述符添加到该列表中。

        2、调用一个系统API——select,监听该列表中的文件描述，直到这些文件描述符中的一个或者过个进行了IO操作，该函数才返回。

        此函数是阻塞的；函数对文件描述符的检测的操作是由内核完成的。

        3、返回时，会告诉进程有多少描述符要进行IO操作。

 其余相关API:

// 将参数文件描述符fd对应的标志位设置为0
void FD_CLR(int fd, fd_set *set);


// 判断fd对应的标志位是0还是1， 返回值 ： fd对应的标志位的值，0，返回0， 1，返回1
int  FD_ISSET(int fd, fd_set *set);


// 将参数文件描述符fd 对应的标志位，设置为1
void FD_SET(int fd, fd_set *set);


// fd_set一共有1024 bit, 全部初始化为0
void FD_ZERO(fd_set *set);

        创建一个文件描述符列表，其大小为1024，代表1024个bit位，对应一个文件描述符。检测四个文件描述符，将对应的文件描述符对应标志位设置为1，调用select函数。nfds+1的作用是让内核遍历的位置。将创建的文件描述符，从用户态拷贝到内核态，由内核进行判断，判断完成后再由内核态拷贝到用户态，进而输出检测结果。 

select.c

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

int main()
{

    //创建socket
    int lfd=socket(PF_INET,SOCK_STREAM,0);
    struct sockaddr_in saddr;
    saddr.sin_port=htons(9999);
    saddr.sin_family=AF_INET;
    saddr.sin_addr.s_addr=INADDR_ANY;
    //绑定
    bind(lfd,(struct sockaddr*)&saddr,sizeof(saddr));

    //监听
    listen(lfd,8);

    //创建一个fd_set集合，存放的是需要检测的文件描述符
    fd_set rdset,tmp;

    //初始化
    FD_ZERO(&rdset);
    //添加要检测的文件描述符
    FD_SET(lfd,&rdset);

    int maxfd=lfd;

    //在循环中监听——调用select函数，让内核帮忙进行检测；
        while(1)
        {
          tmp=rdset;
          int ret = select(maxfd+1,&tmp,NULL,NULL,NULL);
            if(ret==-1)
            {
                perror("select");
                exit(-1);
            }
            else if (ret==0)
            {
                continue;
            }
            else if (ret>0)
            {
                //说明文件描述符对应的缓冲区数据发生了改变；

                if(FD_ISSET(lfd,&tmp))
                {
                   //表示有新的客户端连接进来
                   struct sockaddr_in cliaddr;
                   int len=sizeof(cliaddr);
                   int cfd= accept(lfd,(struct sockaddr *)&cliaddr,&len);
                    printf("新的客户端添加:%d\n",cfd);
                    //将新的文件描述符添加到集合中去；
                     FD_SET(cfd,&rdset);
                    //更新最大的文件描述符
                    maxfd= maxfd>cfd ? maxfd:cfd;
                }

                for(int i=lfd+1;i<=maxfd;i++)
                {
                    if(FD_ISSET(i,&tmp))
                    {
                    //说明这个文件描述符对应的客户端发来了数据；
                    char buf[1024]={0};
                    int len =read(i,buf,sizeof(buf));
                        if(len==-1)
                        {
                            perror("read");
                            exit(-1);
                        } 
                        else if(len==0)
                        {
                            printf("client close...\n");
                            close(i);
                            FD_CLR(i,&rdset);
                        }       
                        else if(len>0)
                        {
                            printf("read buf:%s\n",buf);
                            write(i,buf,strlen(buf+1));
                        }
                    }
                }
            }
        }

        close(lfd);
    return 0;
}

client.c 

#include <stdio.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

int main() {

    // 创建socket
    int fd = socket(PF_INET, SOCK_STREAM, 0);
    if(fd == -1) {
        perror("socket");
        return -1;
    }

    struct sockaddr_in seraddr;
    inet_pton(AF_INET, "127.0.0.1", &seraddr.sin_addr.s_addr);
    seraddr.sin_family = AF_INET;
    seraddr.sin_port = htons(9999);

    // 连接服务器
    int ret = connect(fd, (struct sockaddr *)&seraddr, sizeof(seraddr));

    if(ret == -1){
        perror("connect");
        return -1;
    }

    int num = 0;
    while(1) {
        char sendBuf[1024] = {0};
        sprintf(sendBuf, "send data %d", num++);
        write(fd, sendBuf, strlen(sendBuf) + 1);

        // 接收
        int len = read(fd, sendBuf, sizeof(sendBuf));
        if(len == -1) {
            perror("read");
            return -1;
        }else if(len > 0) {
            printf("read buf = %s\n", sendBuf);
        } else {
            printf("服务器已经断开连接...\n");
            break;
        }
         sleep(1);
       //usleep(1000);
    }

    close(fd);

    return 0;
}

运行结果

服务器：

客户端1

客户端2 

 缺点：

1、每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在内核遍历传递进来的所有fd，这个开销在fd很多时也很大。

2、同时每次调用select都需要在内核遍历传递进来的所有fd,这个开销在fd很多时也很大。

3、select支持的文件描述符数量太小了，默认是1024。

4、fds集合不能重复使用，每次需要重置。

三、poll技术 

改进select中两个缺点：

1、select支持的文件描述符数量太小，默认是1024；

2、fds集合不能重复使用，每次需要重置；

        1024是因为fd_set就是这种类型，改用结构体数组，可以自定义结构体内部大小，再用结构体成员来扩充文件描述符的标志位，可以不需要重置。

对于events和revents的取值有以下的设置：

利用poll实现：

poll.c

#include <sys/poll.h>
#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/select.h>

int main()
{

    //创建socket
    int lfd=socket(PF_INET,SOCK_STREAM,0);
    struct sockaddr_in saddr;
    saddr.sin_port=htons(9999);
    saddr.sin_family=AF_INET;
    saddr.sin_addr.s_addr=INADDR_ANY;
    //绑定
    bind(lfd,(struct sockaddr*)&saddr,sizeof(saddr));

    //监听
    listen(lfd,8);

    //初始化检测的文件描述符数组
    struct pollfd fds[1024];
    for(int i=0;i<1024;i++)
    {
        fds[i].fd=-1;
        fds[i].events=POLLIN;
    }
    fds[0].fd=lfd;
    int nfds=0;
        while(1)
        {
            //调用poll系统函数，让内核帮忙检测哪些文件描述符有数据
            int ret=poll(fds,nfds+1,-1);
            if(ret==-1)
            {
                perror("poll");
                exit(-1);
            }
            else if (ret==0)
            {
                continue;
            }
            else if (ret>0)
            {
                //说明文件描述符对应的缓冲区数据发生了改变；

                if(fds[0].revents&POLLIN)
                {
                   //表示有新的客户端连接进来
                   struct sockaddr_in cliaddr;
                   int len=sizeof(cliaddr);
                   int cfd= accept(lfd,(struct sockaddr *)&cliaddr,&len);
                    printf("新的客户端添加:%d\n",cfd);
                    //将新的文件描述符添加到集合中去；
                     for(int i=1;i<1024;i++)
                     {
                        if(fds[i].fd==-1)
                        {
                            fds[i].fd=cfd;
                            fds[i].events=POLLIN;
                            break;
                        }
                     }
                    //更新最大的文件描述符
                    nfds= nfds>cfd ? nfds:cfd;
                }

                for(int i=1;i<=nfds;i++)
                {
                    if(fds[i].revents & POLLIN)
                    {
                    //说明这个文件描述符对应的客户端发来了数据；
                    char buf[1024]={0};
                    int len =read(fds[i].fd,buf,sizeof(buf));
                        if(len==-1)
                        {
                            perror("read");
                            exit(-1);
                        } 
                        else if(len==0)
                        {
                            printf("client close...\n");
                            fds[i].fd=-1;
                            close(fds[i].fd);
                        }       
                        else if(len>0)
                        {
                            printf("read buf:%s\n",buf);
                            write(i,buf,strlen(buf+1));
                        }
                    }
                }
            }
        }

        close(lfd);
    return 0;
}

运行结果

服务器：

客户端1： 

 客户端2：

四、epoll技术 

poll技术是对select技术的一个改进，解决了select技术中后两个缺点，但是还存在两个缺点：

1、每次调用都要进行一个拷贝；将要检测的文件描述符的信息进行内核的拷贝。

2、调用时仍然需要进行遍历。只能知道有多少返回值发生了改变，但是不知道是哪一个改变了，因此需要进行遍历。

epoll技术原理：

        在内核区创建一个eventpoll数据，返回一个文件描述符，通过这个文件描述符可以操作这块区域的数据。两个重要的成员：rbr与rdlist，rbr采用红黑树的结构；rdlist采用双链表的结构。

        效率提高：1、没有用户态到内核态的拷贝过程；2、之前是线性数组结构，现在是红黑树的结构，现在遍历的速度更快。 

相关API函数说明：

涉及头文件：#include<sys/epoll>

1、 int epoll_creat(int size) 

//创建一个新的epoll实例，在内核中创建了一个数据，这个数据中有两个主要的数据，一个是需要检测的文件描述符的信息（红黑树），一个是就绪列表，存放检测到数据发生改变的文件描述符信息（双向链表）。

        参数：目前没有意义；随便一个数就行；

        返回值：-1，失败。>0，文件描述符，用来操作epoll实例；

2、int epoll_ctl（int epfd,int op,int fd,struct epoll_event *event);

//对epoll实例进行管理，添加、删除、修改文件描述符信息；

        参数：

                epfd:epoll实例对应的文件描述符；

                op:要进行什么操作；

                         EPOLL_CTL_ADD:  添加
                         EPOLL_CTL_MOD: 修改
                         EPOLL_CTL_DEL: 删除

                fd：要检测的文件描述符，

                event：要检测文件描述符什么事情；

             

        struct epoll_event {
                uint32_t     events;      /* Epoll events */
                epoll_data_t data;        /* User data variable */
                                     }

                常见的Epoll检测事件：
                   - EPOLLIN
                   - EPOLLOUT
                   - EPOLLERR

                typedef union epoll_data {
                        void        *ptr;
                        int          fd;
                        uint32_t     u32;
                        uint64_t     u64;
                } epoll_data_t;

3、int epoll_wait(int epfd,struct epoll_event *events,int maxevents,int timeout)

      //检测函数

        参数：epfd：epoll实例对应的文件描述符；

                events:传出参数，保存了发送了变化的文件描述符信息；

                maxevents：第二个参数结构体数组的大小；

                timeout：阻塞时间；

                        0：不阻塞；-1:阻塞(直到检测到fd数据发生变化，解除阻塞)；

                        >0:阻塞的时长(毫秒)；

        返回值：

                        成功返回发生变化的描述符的个数；失败返回-1；

epoll.c

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

int main()
{
    //创建socket
    int lfd=socket(PF_INET,SOCK_STREAM,0);
    struct sockaddr_in saddr;
    saddr.sin_port=htons(9999);
    saddr.sin_family=AF_INET;
    saddr.sin_addr.s_addr=INADDR_ANY;
    //绑定
    bind(lfd,(struct sockaddr*)&saddr,sizeof(saddr));

    //监听
    listen(lfd,8);

      //调用epoll_creat 创建一个epoll实例
        int epfd= epoll_create(100);
      //将监听的文件描述符相关的检测信息添加到epoll实例中；
      struct epoll_event epev;
      epev.events=EPOLLIN;
      epev.data.fd=lfd;
      epoll_ctl(epfd,EPOLL_CTL_ADD,lfd,&epev);
        struct epoll_event epevs[1024];
      while(1)
      {
        int ret=epoll_wait(epfd,epevs,1024,-1);
        if(ret==-1)
        {
             perror("epoll_wait");
             exit(-1);   
        }
        printf("ret=%d\n",ret);
        for(int i=0;i<ret;i++)
        {
            int curfd=epevs[i].data.fd;

            if(curfd==lfd)
            {
                //有客户端连接
                struct sockaddr_in cliaddr;
                int len=sizeof(cliaddr);
                int cfd= accept(lfd,(struct sockaddr *)&cliaddr,&len);
                printf("新的客户端添加:%d\n",cfd);

                 epev.events=EPOLLIN;
                 epev.data.fd=cfd;
                 epoll_ctl(epfd,EPOLL_CTL_ADD,cfd,&epev);
            }
            else{
                // if(epevs[i].events&EPOLLOUT)
                // {
                //     continue;
                // }
                //有数据到达
                 char buf[1024]={0};
                    int len =read(curfd,buf,sizeof(buf));
                        if(len==-1)
                        {
                            perror("read");
                            exit(-1);
                        } 
                        else if(len==0)
                        {
                            printf("client close...\n");
                            epoll_ctl(epfd,EPOLL_CTL_DEL,curfd,NULL); 
                            close(curfd);
                        }       
                        else if(len>0)
                        {
                            printf("read buf:%s\n",buf);
                            write(curfd,buf,strlen(buf+1));
                        }
            }
        }
      }
    close(lfd);
    close(epfd);
    return 0;
}

 client.c

#include <stdio.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

int main() {

    // 创建socket
    int fd = socket(PF_INET, SOCK_STREAM, 0);
    if(fd == -1) {
        perror("socket");
        return -1;
    }

    struct sockaddr_in seraddr;
    inet_pton(AF_INET, "127.0.0.1", &seraddr.sin_addr.s_addr);
    seraddr.sin_family = AF_INET;
    seraddr.sin_port = htons(9999);

    // 连接服务器
    int ret = connect(fd, (struct sockaddr *)&seraddr, sizeof(seraddr));

    if(ret == -1){
        perror("connect");
        return -1;
    }

    int num = 0;
    while(1) {
        char sendBuf[1024] = {0};
        sprintf(sendBuf, "send data %d", num++);
        write(fd, sendBuf, strlen(sendBuf) + 1);

        // 接收
        int len = read(fd, sendBuf, sizeof(sendBuf));
        if(len == -1) {
            perror("read");
            return -1;
        }else if(len > 0) {
            printf("read buf = %s\n", sendBuf);
        } else {
            printf("服务器已经断开连接...\n");
            break;
        }
         //sleep(1);
       usleep(1000);
    }

    close(fd);

    return 0;
}

运行结果：

  epoll.c

客户端1

客户端2

 epoll的工作模式：

     LT模式（水平触发）

        假设委托内核检测读事件->检测fd的读缓冲区；

        读缓冲区有数据->epoll检测到了会给用户通知；

                用户不读数据，数据一直在缓冲区，epoll会一直通知；

                用户只读了一部分数据，epoll会一直通知；

                缓冲区数据读完了，不通知。

        LT(level-triggered)是缺省的工作方式（默认工作模式），并且同时支持block与no block socket。内核告诉你一个文件描述符是否就绪，然后你可以对这个就绪的fd进行IO操作。如果你不做任何操作，内核还是继续通知你。

     ET模式（边沿触发）

  假设委托内核检测读事件->检测fd的读缓冲区；

        读缓冲区有数据->epoll检测到了会给用户通知；

                用户不读数据，数据一直在缓冲区，epoll下次检测的时候就不通知；

                用户只读了一部分数据，epoll不通知；

                缓冲区数据读完了，不通知。

        ET（edge-trigged）是高速工作方式，只支持no-clock socket，在这种工作模式下，当描述符从未就绪变为就绪时，内核通过epoll告诉你，然后他会假设你知道文件描述符已经就绪，并且不会再为那个文件描述符发送更多的就绪通知，直到你做了某些操作导致那个文件描述符不再为就绪态，但是请注意，如果一直不对这个fd进行IO操作（从而导致它再次变成未就绪态），内核不会发送更多的通知。

        ET模式在很大程度上减少了epoll事件被重复触发的次数，因此效率比LT模式高，epoll工作在ET模式的时候，必须使用非阻塞套接口，以避免由一个文件句柄的阻塞读/写操作把处理多个文件描述符的任务饿死。

水平触发测试：

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

int main()
{
    //创建socket
    int lfd=socket(PF_INET,SOCK_STREAM,0);
    struct sockaddr_in saddr;
    saddr.sin_port=htons(9999);
    saddr.sin_family=AF_INET;
    saddr.sin_addr.s_addr=INADDR_ANY;
    //绑定
    bind(lfd,(struct sockaddr*)&saddr,sizeof(saddr));

    //监听
    listen(lfd,8);

      //调用epoll_creat 创建一个epoll实例
        int epfd= epoll_create(100);
      //将监听的文件描述符相关的检测信息添加到epoll实例中；
      struct epoll_event epev;
      epev.events=EPOLLIN;
      epev.data.fd=lfd;
      epoll_ctl(epfd,EPOLL_CTL_ADD,lfd,&epev);
        struct epoll_event epevs[1024];
      while(1)
      {
        int ret=epoll_wait(epfd,epevs,1024,-1);
        if(ret==-1)
        {
             perror("epoll_wait");
             exit(-1);   
        }
        printf("ret=%d\n",ret);
        for(int i=0;i<ret;i++)
        {
            int curfd=epevs[i].data.fd;

            if(curfd==lfd)
            {
                //有客户端连接
                struct sockaddr_in cliaddr;
                int len=sizeof(cliaddr);
                int cfd= accept(lfd,(struct sockaddr *)&cliaddr,&len);
                printf("新的客户端添加:%d\n",cfd);

                 epev.events=EPOLLIN;
                 epev.data.fd=cfd;
                 epoll_ctl(epfd,EPOLL_CTL_ADD,cfd,&epev);
            }
            else{
                // if(epevs[i].events&EPOLLOUT)
                // {
                //     continue;
                // }
                //有数据到达
                 char buf[5]={0};
                    int len =read(curfd,buf,sizeof(buf));
                        if(len==-1)
                        {
                            perror("read");
                            exit(-1);
                        } 
                        else if(len==0)
                        {
                            printf("client close...\n");
                            epoll_ctl(epfd,EPOLL_CTL_DEL,curfd,NULL); 
                            close(curfd);
                        }       
                        else if(len>0)
                        {
                            printf("read buf:%s\n",buf);
                            write(curfd,buf,strlen(buf+1));
                        }
            }
        }
      }
    close(lfd);
    close(epfd);
    return 0;
}

服务器

 客户端

边沿触发：

 边沿触发不是默认的，需要进行设置；在哪设置呢？常见的Epoll检测事件，添加EPOLLET；

 

         设置了边沿触发，这种模式你要检测的缓冲区里面有数据，epoll检测的时候会通知你，如果没有读取完，epoll再次检测的时候，就不会通知你了。        

        再次发送数据，他就还能触发一次，读取顺序按照读缓冲区中的内容顺序进行读取的。那么边沿触发如果要一次性将数据读出来，那如何操作呢？

   

#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/epoll.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
int main()
{
    //创建socket
    int lfd=socket(PF_INET,SOCK_STREAM,0);
    struct sockaddr_in saddr;
    saddr.sin_port=htons(9999);
    saddr.sin_family=AF_INET;
    saddr.sin_addr.s_addr=INADDR_ANY;
    //绑定
    bind(lfd,(struct sockaddr*)&saddr,sizeof(saddr));

    //监听
    listen(lfd,8);

      //调用epoll_creat 创建一个epoll实例
        int epfd= epoll_create(100);
      //将监听的文件描述符相关的检测信息添加到epoll实例中；
      struct epoll_event epev;
      epev.events=EPOLLIN;
      epev.data.fd=lfd;
      epoll_ctl(epfd,EPOLL_CTL_ADD,lfd,&epev);
        struct epoll_event epevs[1024];
      while(1)
      {
        int ret=epoll_wait(epfd,epevs,1024,-1);
        if(ret==-1)
        {
             perror("epoll_wait");
             exit(-1);   
        }
        printf("ret=%d\n",ret);
        for(int i=0;i<ret;i++)
        {
            int curfd=epevs[i].data.fd;

            if(curfd==lfd)
            {
                //有客户端连接
                struct sockaddr_in cliaddr;
                int len=sizeof(cliaddr);
                int cfd= accept(lfd,(struct sockaddr *)&cliaddr,&len);
                printf("新的客户端添加:%d\n",cfd);
                //设置cfd非阻塞属性；
               int flag= fcntl(cfd,F_GETFL);
                  flag |=O_NONBLOCK;
                  fcntl(cfd,F_SETFL,flag);

                 epev.events=EPOLLIN | EPOLLET;//设置边沿触发
                 epev.data.fd=cfd;
                 epoll_ctl(epfd,EPOLL_CTL_ADD,cfd,&epev);
            }
            else{
                if(epevs[i].events&EPOLLOUT)
                {
                    continue;
                }
               //循环读取所有数据
               char buf[5]={0};
               int len=0;
               while((len=read(curfd,buf,sizeof(buf)))>0)
               {
               //打印数据
               // printf("recv data:%s\n",buf);
                write(STDOUT_FILENO,buf,len);
                write(curfd,buf,len);
               }
            if(len==0)
            {
              printf("client closed...");
              }
            else if (len==-1)
            {
            if(errno==EAGAIN)
            {
              printf("data over....");
            }else
            {
             perror("read");
              exit(-1);
            }
            }
            }
        }
      }
    close(lfd);
    close(epfd);
    return 0;
}

服务器端： 

 客户端：

King~30+
关注
  • 18
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java NIO - IO多路复用
Liarboy
09-28 3207
提供了非阻塞调用的方式，从操作系统层面解决了阻塞问题。将 socket 是否就绪检查逻辑下沉到操作系统层面，避免大量系统调用。告诉你有事件就绪，但是没告诉你具体是哪个 FD。epoll 直接将 fd 集合维护在内核中，通过红黑树来高效管理 fd 集合，同时维护一个就绪列表，当 fd 就绪后会添加到就绪列表中，当应用空间调用 epoll_wait 获取就绪事件时，内核直接判断就绪列表即可知道是否有事件就绪。
IO多路复用之epoll全面总结(必看篇)
09-15
在Linux系统中，epoll是针对IO多路复用的一种高效实现，尤其适用于大规模并发连接的场景。以下是关于epoll的详细总结： 1. **基本概念** - **epoll** 是在Linux 2.6内核引入的，是对早期的`select`和`poll`函数的...
Linux编程--IO多路复用
xinqi_1的博客
06-17 2032
IO多路复用是指通过一种机制，使得单个进程可以监控多个文件描述符的可读、可写和异常等事件。常见的IO多路复用技术包括：select、poll、epoll等。在实际应用中，IO多路复用可以提高程序的运行效率和性能，减少系统开销，降低系统资源的使用率。它广泛应用于网络编程、服务器开发、操作系统等领域，可以帮助开发人员更好地处理大量的网络连接和数据请求。
Linux网络编程—— IO多路复用
weixin_43412762的博客
03-03 1988
 I/O 多路复用 使得程序能 同时监听 多个文件描述符，能够提高程序的性能，Linux 下实现 I/O 多路复用 的 系统调用主要有 select、poll 和 epoll。
Java---IO多路复用
优秀的威的博客
09-16 1386
IO多路复用的底层原理1. linux操作系统中断1.1 什么是系统中断？1.2 系统中断，内核会做什么？1.3 什么是系统中断？ 1. linux操作系统中断 1.1 什么是系统中断？ 软中断：由CPU产生 除以0 硬中断：由硬件产生 每种中断对应一个中断处理程序 — 80中断处理程序—系统调用 1.2 系统中断，内核会做什么？ 1.3 什么是系统中断？ ...
Linux小知识---常见的IO复用技术
小人物的编程
11-23 1447
介绍了IO多路复用常用的集中方式，并且介绍了优缺点
Linux的IO多路复用
03-27 3481
博客主页：🏆看看是李XX还是李歘歘🏆 🌺每天分享一些包括但不限于计算机基础、算法等相关的知识点🌺 💗点关注不迷路，总有一些📖知识点📖是你想要的💗 ⛽️今天的内容是 Linux的IO多路复用 ⛽️💻💻💻 五种网络IO：阻塞IO、非阻塞IO、信号驱动IO、多路复用IO和异步IO，今天来聊一下多路复用IO在linux的实现。 I/O多路复用：以较少的代价来同时监听文件描述符，处理多个IO，一旦某个描述符就绪，通知程序进行相应处理，多路复用IO属于同步IO，Linux的IO...
IO模型---IO多路复用
m0_68004652的博客
11-22 281
内核层IO多路复用
IO多路复用详解
氷的博客
05-30 1509
在IO多路复用模型中，引入了一种新的系统调用，查询IO的就绪状态。在Linux系统中，对应的系统调用为select/poll/epoll系统调用。通过该系统调用，一个进程可以监视多个文件描述符，一旦某个描述符就绪（一般是内核缓冲区可读/可写），内核能够将就绪的状态返回给应用程序。随后，应用程序根据就绪的状态，进行相应的IO系统调用。在IO多路复用模型中通过select/poll/epoll系统调用，单个应用程序的线程，可以不断地轮询成百上千的socket连接，当某个或者某些socket网络连接有IO就绪的状
【Linux】网络篇四--IO多路复用
修成真的博客
04-02 1554
网络篇四--IO多路复用一、阻塞I/O模型1、阻塞I/O 模式（1）读阻塞（2）写阻塞2、非阻塞模式I/O二、多路复用I/O1、select()函数2、epoll()函数 一、阻塞I/O模型 在UNIX/Linux下主要有4种 I/O 模型： 阻塞I/O ：最常用 非阻塞I/O ：可防止进程阻塞在I/O操作上，需要轮询 I/O 多路复用 ：允许同时对多个I/O进行控制 信号驱动I/O : 一种异步通信模型 1、阻塞I/O 模式 阻塞I/O 模式是最普遍使用的I/O 模式，大部分程序使用的都是阻塞模.
Redis网络模型-IO多路复用
mqq2502513332的博客
10-31 850
Redis网络模型-IO多路复用
io多路复用解析
12-07
在 Linux 系统中，IO 多路复用机制主要有三种实现方式：Select、Poll 和 Epoll。这里我们将对 Select 和 Poll 两种机制进行详细的解析。 Select 多路复用 Select 是一种传统的 IO 多路复用机制，通过使用 fd_set ...
IO多路复用之poll全面总结(必看篇)
09-15
总的来说，poll是Linux系统中实现IO多路复用的重要工具，它提供了比select更灵活的事件检测机制，特别是在处理大量并发连接时，能有效地避免了文件描述符数量的限制。理解并熟练掌握poll机制，对于编写高性能的网络...
Linux IO多路复用之epoll网络编程
09-15
在Linux系统中，IO多路复用是一种高效的网络编程技术，它允许多个网络连接在同一时间进行处理，而不需要为每个连接创建单独的线程或进程。`epoll`是Linux内核提供的一种IO多路复用机制，特别适合于高并发、高性能的...
IO多路复用实现TCPecho
03-02
本文将深入探讨如何利用IO多路复用来实现一个TCP echo服务器，该服务器运行在Linux环境下。 首先，让我们理解什么是TCP echo服务器。TCP echo服务器是一种简单的网络应用，它的主要任务是接收客户端发送的数据，并...
Linux日常运维小结
lza20001103的博客
08-14 362
Linux日常运维小结
Linux Day1 系统编程和文件操作
qq_63145217的博客
08-12 1021
1）使用标准库函数如fopen, fclose, fread, fwrite, fgetc, fputc, fgets, fprintf, fscanf等进行文件操作。1）用套接字（sockets）API，包括socket, bind, listen, accept, connect, send, recv等函数进行网络通信。nmemb 要写的数据块的个数（一般为sizeof（ptr））->1个1个读，到sizeof（ptr）为止。nmemb 要获取的数据块的个数，拷贝的数据块个数。
Linux中线程接口（分离，查看id）mv指令
2301_77479435的博客
08-14 484
Linux中线程接口（分离，查看id）mv指令
mediun level Linux commands on netstat, SCP, ＞＞, SSH, etc
最新发布
DavidsonGong的博客
08-14 84
【代码】mediun level Linux commands on netstat, SCP, ＞＞, SSH, etc。
linux下的io多路复用
04-08
在Linux下，IO多路复用是一种高效的IO处理机制，它允许一个进程同时监视多个文件描述符的可读、可写或异常事件。通过使用IO多路复用，可以避免使用阻塞IO或者多线程/多进程的方式来处理并发IO操作，提高系统的性能和资源利用率。 Linux下常用的IO多路复用机制有以下三种： 1. select：select函数是最早引入的IO多路复用机制，它通过一个位图来表示需要监视的文件描述符集合，并通过轮询的方式检查每个文件描述符的状态变化。select函数的缺点是，每次调用时需要将所有待监视的文件描述符集合从用户态拷贝到内核态，导致性能较低。 2. poll：poll函数是对select函数的改进，它使用链表来表示需要监视的文件描述符集合，并通过轮询的方式检查每个文件描述符的状态变化。相比select函数，poll函数不需要将文件描述符集合从用户态拷贝到内核态，性能有所提升。 3. epoll：epoll是Linux特有的IO多路复用机制，它通过使用事件驱动的方式来处理IO事件。epoll使用一个事件表来存储需要监视的文件描述符和对应的事件类型，并通过回调函数来处理事件。相比select和poll，epoll具有更高的性能和扩展性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值