IO多路复用

最新推荐文章于 2024-06-09 10:08:39 发布
最新推荐文章于 2024-06-09 10:08:39 发布
阅读量777 收藏 2
点赞数
分类专栏： Linux 文章标签： 客户端 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aoeaoao/article/details/126456158
版权

多路IO复用

阻塞IO

服务器一般为了处理客户端代码，有以下操作

socket()   //打开一个网络通信端口               
bind()     //绑定                 
listen()   //监听            
accept()   //阻塞建立连接        
recv()     //阻塞读取数据                   
send()     //给客户端回放数据
close()    //关闭连接

客户端则需要以下操作

socket()  //打开一个网络通信端口
connect() //与客户端进行连接
send()    //给客户端发送数据
recv()    //从客户端那里读取数据
close()   //关闭连接

这个时候，服务端的线程往往阻塞在两个地方

一个是accpet函数

等到有客户端来连接才会解除阻塞

一个是read函数

read函数会一直阻塞，直到数据从网卡到达内核缓冲区，接着文件描述符准备就绪，接着解除阻塞，把数据从内核缓冲区读到数据缓冲区
在这里插入图片描述

所以当连接的客户端一直不发数据，那么服务端线程就会一直阻塞在read函数，无法接受其它用户连接。

有一种解决办法，就是我们每次可以创建一个新的线程或进程，去调用read函数，并做业务处理，让主函数中的执行路径可以一直执行下去，而不被阻塞。

多线程

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<netinet/in.h>
#include<bits/socket.h>
#include<arpa/inet.h>
#include<sys/socket.h>
#include<pthread.h>
int sock_init()
{
  int socketfd = socket(AF_INET,SOCK_STREAM,0);
  if(socketfd == -1)
  {
   printf("socket erro\n");
   exit(1);
  }
  struct sockaddr_in saddr,caddr;
  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(socketfd,(struct sockaddr *)&saddr,sizeof(saddr));
  if(res == -1)
  {
   printf("bind erro \n");
   exit(1);
  }
  res = listen(socketfd,5);
  if(res == -1)
  {
    printf("listen erro\n");
    exit(1);
  }
 return socketfd;

}
void * fun(void *);
int main()
{
 int socketfd = sock_init();
 while(1)
 {

   struct sockaddr_in caddr;
   int len = sizeof(caddr);
   int c = accept(socketfd,(struct sockaddr *)&caddr,&len);
   if(c<=0)
   {
     printf("accept erro\n");
     break;
   
   }
   printf("c=%d,ip=%s,port=%d",c,inet_ntoa(caddr.sin_addr),ntohs(caddr.sin_port));
   pthread_t id;
   pthread_create(&id,NULL,fun,(void *)c);
 
   }
}
void * fun(void * arg)
{
 int c = (int)arg;
  while(1)
  {
   char buff[128]={0};
   int n = recv(c,buff,127,0);
   if(n<=0)
   {
    break;
   
   }
   printf("recive len = %d %s\n",n,buff);
   send(c,"ok",2,0);
  }
  printf("c(%d)close\n",c);
  close(c);

}

多进程

#include<stdio.h>
#include<sys/wait.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<netinet/in.h>
#include<bits/socket.h>
#include<arpa/inet.h>
#include<sys/socket.h>
#include<pthread.h>
#include<signal.h>
void fun(int sig)
{
  wait(NULL);

}
int sock_init()
{
  int socketfd = socket(AF_INET,SOCK_STREAM,0);
  if(socketfd == -1)
  {
   printf("socket erro\n");
   exit(1);
  }
  struct sockaddr_in saddr,caddr;
  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(socketfd,(struct sockaddr *)&saddr,sizeof(saddr));
  if(res == -1)
  {
   printf("bind erro \n");
   exit(1);
  }
  res = listen(socketfd,5);
  if(res == -1)
  {
    printf("listen erro\n");
    exit(1);
  }
 return socketfd;

}
int main()
{
 signal(SIGCHLD,fun);
 int socketfd = sock_init();
 while(1)
 {

   struct sockaddr_in caddr;
   int len = sizeof(caddr);
   int c = accept(socketfd,(struct sockaddr *)&caddr,&len);
   if(c<=0)
   {
     printf("accept erro\n");
     break;
   
   }
   printf("c=%d,ip=%s,port=%d\n",c,inet_ntoa(caddr.sin_addr),ntohs(caddr.sin_port));
   pid_t pid = fork();
  if(pid ==0)
  {
  
    while(1)
   {
     char buff[128]={0};
     int n = recv(c,buff,127,0);
     if(n<=0)
    {
      break;
   
    }
     printf("c(%d) recive len = %d %s\n",c,n,buff);
     send(c,"ok",2,0);
  
   } 
  printf("c(%d)close\n",c);
  close(c);
  }
 
 }
  exit(0);
}

非阻塞IO

我们需要操作系统为我们提供一个非阻塞的read函数

这个read函数的效果是，如果没有数据到达时（到达网卡并到达内核缓冲区），立刻返回一个错误值 -1 ，而不是阻塞地等待。

操作系统提供了这样的功能，只需要在调用read前，将文件描述符设置为非阻塞即可。

fcntl(c,F_SETFL,O_NONBLOCK);
int n = read((c,buffer) != SUCCESS);

在这里插入图片描述
这个时候，我们可以当一个客户端连接后，将这个文件描述符放到一个数组中，然后弄出一个新的线程去不断的遍历这个数组，调用每一个元素的非阻塞read方法

while(1)
{
 for(int fd;fdarry)
 {
   if(read(fd) ！= -1)
   {
   }
 }
}

但是这样每次遍历就要不停的调用read，当某个连接上没有数据时，read返回为-1时，这就白白的执行了一次系统调用，这种极大的浪费了系统资源。

IO多路复用

IO复用方法有 ：
1.select
2. poll
3. epoll（Linux上特有的） Windows上与之对应的方法(iocp)

select

select是系统调用函数，通过它，我们可以把一个文件描述符的数组发给操作系统，让操作系统去遍历，确定那个文件描述符可以读写，然后告诉我们去处理

函数原型

int select(
        int nfds, 
         fd_set * readfds,
         fd_set * wirtefds,
         fd_set * exceptfds,
         struct timeval * timeout);
         /* nfds : 监控文件描述符集李最大文件描述符加1
         *  readfds: 监控有读数据到达文件描述符集合
         *  writefds: 监控些数据到达文件描述符集合
         * exceptfds: 监控异常发送到达文件描述符集合
         * timeout:   定时阻塞监控时间，3种情况
         * 1.NULL,永远等下去
         * 2.设置timeval,等待固定时间
         * 3.设置timevals里时间均为0，检查描述字后立马返回 
         * struct timeval
         * {
         *   long tv_sec;//秒数
         *   long tv_usec;//微妙数
         * };
         */

select的返回值：

select在成功时****返回就绪描述符的总数
如果在超时时间内没有任何描述符准备就绪，那么select将返回0，
如果在select期间程序收到信号，则select将返回-1，代表select失败，并设置errno为EINTR。

通过以下描述符可以访问fd_set中的位

      FD_ZERO(fd_set * fdset) //清除fdset中的所有位
      FD_SET(int fd,fd_set * fdset)//设置fdset的位fd
      FD_CLR(int fd,fd_set * fdset)//清除fdset的位fd
      int FD_ISSET(int fd_set * fdset) //检测fdset中的位fd是否被设置

在这里插入图片描述
fd_set实际是一个为1024位的数据，它可以存放值为0~1023的描述符
当描述符的值为0时，它就把fd_set的第0位的值置为0，当值为1时，就把fd_set的第1位的值置为1。

所以它只能监听1024个文件描述符。

代码实现

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<netinet/in.h>
#include<bits/socket.h>
#include<arpa/inet.h>
#include<sys/socket.h>
#include<sys/select.h>
#include<sys/time.h>
#define MAX 10
void accept_client(int sockfd,int fds[])
{
 struct sockaddr_in caddr;
 int len = sizeof(caddr);
 int  c =accept(sockfd,(struct sockaddr *)&caddr,&len);

 if(c < 0 )
 {
  return ;
 }
 printf("accept c =%d\n",c);
 fds_add(fds,c);
}
void fds_init(int fds[])
{
 
    for(int i=0;i<MAX;++i)
    {
     fds[i]=-1;
    }

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

}
void fds_del(int fds,int fd)
{
 for(int i=0;i<MAX;++i)
 {
  if(fds [i] == fd)
  {
   fds[i] =-1;
   break;
  }
 
 }
}
int sockinit()
{
  int sockfd = socket(AF_INET,SOCK_STREAM,0);
  if(sockfd == -1)
  {
    printf("sock erro\n");
   return -1;
  }
 struct  sockaddr_in saddr;
 memset(&saddr,0,sizeof(saddr));
 saddr.sin_familm = AF_INET;
 saddr.sin_port = htons(6000);
 saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
 
 int res = bind(sockfd,0,(struct saddr *)&saddr,sizeof(saddr));
 if(res == -1)
 {
  printf("bind erro\n");
  return -1;
 }
 res = listen(sockfd,5);
 if(res  == -1)
 {
  printf("listen erro\n");
  return -1;
 }
 return res;
}
void recv_data(int fd,int fds[])
{
 char buff[128] ={0};
 int num = recv(fd,buff,127,0);
 if(num < 0)
 {
  close(fd);
  fds_del(fds,fd);
  printf("close\n");
  return ;
 }
 printf("buff = %s\n",buff);
 send(fd,"ok",2,0);


}
int main()
{
   int sockfd = sockinit();
   if(sockfd == -1)
   {
     exit(1);
  }
   int fds[MAX];
   fds_init(fds);
   fds_add(fds,sockfd);
   fd_set fdset;
   while(1)
  {
    FD_ZERO(&fdset);//FD_ZERO:将文件描述符集合清空
    int maxfd =-1;
    for(int i=0;i<MAX;++i)
   {
      if(fds[i]==-1)
      {
        continue;
      }
       FD_SET(fds[i],&fdset);//将文件描述符添加到文件描述符集合中
       if(maxfd < fds[i])
      {
        masfd = fds[i];
      }
  
    }
 
  }
  struct timaval tv = {5,0}; //设置定时时间
  int n = select(maxfd+1,&fdset,NULL,NULL,&tv);//select的返回值为就绪的描述符数目
  if(n == -1)
   {
    printf("select erro\n");

   }else if(n ==0)
   {
      printf("time out \n");
   }else
   {
     for(int i=0;i<MAX;++i)
    {
      if(fds[i] == -1)
     {
      continue;
     }
     if(FD_ISSET(fds[i],&fdset))//判断该描述符是否就绪
     {
      if(fds[i] == sockfd)
      {
       accept_client(sockfd,fds);
      }else
      {
        recv_data(fds[i].fds);
      }
     
     }
   }
 
   }

   return 0;
}

注意：
1.select调用需要传入fd数组，而这个数组会被拷贝到内核空间，当高并发下这样会消耗大量的资源
2. select在内核层依然是通过遍历方式检查文件描述符的就绪状态，是同步过程，只不过少了系统调用上下文切换的资源开销。
3. select仅仅返回就绪文件符的数目，具体哪个就绪还需要用户自己遍历

select的开销， 一次select + n 次就绪的文件描述符的read 开销

poll

它与select不同是，它没有最多文件描述符的限制

函数原型

int poll 
   (
       struct pollfd * fds,
       nfds_t nfds, 
       int timeout)
       /*
       * fds 指定用户感兴趣的文件描述符上发生的可读，可写，异常事件 pollfd的结构体定义如下
       * struct pollfd
       * {
       *   int fd;//文件描述符
       *   short events;//注册的关注事件类型
       *   short revents;//实际发生的事件类型，由内核进行填充。
       * };
       * nfds  指定被监听事件集合fds的大小
       * timeout指定poll的超时值，单位是毫秒
       * timeout为-1时，poll调用将永久阻塞，直到某个事件发生
       * timeout为0时，poll调用将立即返回
       * 
       * 
       */

事件类型
在这里插入图片描述

代码实现

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

#define MAX 10

void evs_init(struct pollfd evs[])
{
 for(int i=0;i<MAX;++i)
 {
     evs[i].fd =-1;
     evs[i].events =0;
     evs[i].revents =0; 
 }
}
void evs_add(struct pollfd evs [],int fd)
{
 for(int i=0;i<MAX;++i)
 {
  if(evs[i].fd == -1)
  {
   evs[i].fd = fd;
   evs[i].events = POLLIN;
   evs[i].revents = 0;
   break;
  }
 
 }
}
void evs_del(struct pollfd evs[], int fd)
{
  for(int i=0;i<MAX;++i)
  {
   if(evs[i].fd == fd)
   {
    evs[i].fd =-1;
    evs[i].events  = 0;
    evs[i].revents = 0;
    break;
   }
  
  
  }
}
void accept_client(int sockfd,struct pollfd evs[])
{
    struct sockaddr_in caddr;
    int len = sizeof(caddr);
    int c = accept(sockfd,(struct sockaddr *)&caddr,&len);
    if(c <0)
    {
     printf("accept erro\n");
     return ;
    }
    printf("accept %d\n",c);
    evs_add(evs,c);


}
void recv_data(int c,struct pollfd evs[])
{
 char buff[128]={0};
 int num = recv(c,buff,127,0);
 if(num <0)
 {
  evs_del(evs,c);
  close(c);
  printf("%d close\n",c);
  return ;

 }
 printf("data = %s\n",buff);
 send(c,"ok",2,0);

}
int socket_init();
int main()
{
    int sockfd = socket_init();
    if(sockfd == -1)
    {
      printf("socketfd init erro\n");
      exit(1);
    }
    struct pollfd evs[MAX];
    evs_init(evs);

    evs_add(evs,sockfd);
    
    while(1)
    {
      int n = poll(evs,MAX,5000);
      if(n == -1)
      {
       printf("poll erro\n");
      }else if(n == 0)
      {
       printf("time out\n");
      }else
      {
        for(int i=0;i<MAX;++i)
       {
         if(evs[i].fd ==-1)
         {
          continue;
         }
         if(evs[i].revents & POLLIN)
         {
          if(evs[i].fd == sockfd)
          {
        
            accept_client(sockfd,evs);
          }else
          {
           recv_data(evs[i].fd,evs);
          }
         }
        }
     
       }
    }


    return 0;
}
int socket_init()
{

    int sockfd = socket(AF_INET,SOCK_STREAM,0);
    if(sockfd  == 0)
    {
     printf("sockfd erro\n");
     return -1;
    }
    struct sockaddr_in saddr;
    memset(&saddr,0,sizeof(saddr));
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(6001);
    saddr.sin_addr.s_addr = inet_addr("127.0.0.1");

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

}

epoll

特点

1.内核中保存一份文件描述符集合，无需用户每次都重新传入，只需告诉内核要修改的部分即可
2.内核不再通过轮询方式找到就绪的文件描述符，而是通过异步IO事件唤醒
3.内核仅会将有IO事件的文件描述符返回给用户，用户无需遍历整个文件描述符集合
 4.与select和poll相比它还有边沿模式

epoll有EPOLLLT（水平触发）和EPOLLET（边沿触发）两种触发模式
EPOLLLT和select和poll的触发方式一样，都是水平触发，即只要内核缓冲区有数据，就会让该连接的文件描述符有绪
而对应边沿触发来说，当数据从网卡到达内核缓冲区后，它只提示一次，所以在EPOLLET模式下，当read进行读取数据时，一定要把所有数据一次性读完。

epoll的三个函数各自的原型

int epoll(int size);
/*
*  epoll成功返回内核事件表的文件描述符，失败返回-1
* size参数并不起作用，只是给内核一个提示，告诉它事件表需要多大
*/

int epoll_ctl
(  
    int epfd,
    int op , 
    int fd , 
    struct epoll_event * event);
    /*
    * epoll_ctl 成功返回0 ，失败返回-1
    * epfd 参数指定要操作的内核事件表的文件描述符
    * fd 参数指定要操作的文件描述符
    * op 指定要操作的数据类型：
    * EPOLL_CTL_ADD  往内核事件表中注册fd上的事件
    * EPOLL_CTL_MOD  修改fd上面的注册事件
    * EPOLL_CTL_DEL  删除fd上面的注册事件
    * event参数指定事件，它是epoll_event结构指针类型，epoll_event的定义如下
    * struct epoll_event
    * {
    *   _uint32_t events;//epoll事件
    *   epoll_data_t data;//用户数据
    * };
    *  events成员描述事件类型,epoll支持的事件类与poll基本相同，表示epoll事件的宏是在poll对应的宏前       
    * 面加‘E’,它有两个额外的事件EPOLLET和EPOLLONESHOT
    * struct epoll_evnet中的data是一个联合体，用于存储用户数据
    *  typedef union epoll_data
    * {
    *   void *ptr;
    *   int fd; //指定事件所属的目标文件描述符
    *   uint32_t u32;
    *   uint64_t u64; 
    * }
    */

int epoll_wait
(   
   int epfd,
   struct epoll_event *events,
   int maxevents,
   int timeout);
   /* 
   * epoll_wait返回就绪文件描述符个数，失败返回-1，超时返回0
   *  epfd参数指定要操作的内核事件表的文件描述符
   * events是一个用户数组，在eopll_wait返回时保存内核检测到的所有就绪事件
   * maxevents 参数指定用户数组大小，即最多监听多少个事件，必须大于0
   * timeout指定超时时间，单位为毫秒,
   * timeout为0，则epoll_wait会立即返回
   * timeout为-1，则epoll_wait会一直阻塞，直到有事件就绪
   */

代码实现

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

#define MAX 10
void epoll_add(int epfd,int fd)
{
 struct epoll_event ev;
 ev.data.fd =fd;
 ev.events = EPOLLIN;
 if(epoll_ctl(epfd,EPOLL_CTL_ADD,fd,&ev) == -1)
 {
  printf("epoll_ctl erro\n");
 
 }
}
void epoll_del(int epfd,int fd)
{
  if(epoll_ctl(epfd,EPOLL_CTL_DEL,fd,NULL) == -1)
  {
   printf("epoll ctl del erro\n");
  
  }
}
void accept_client(int sockfd,int epfd)
{
    struct sockaddr_in caddr;
    int len = sizeof(caddr);
    int c = accept(sockfd,(struct sockaddr *)&caddr,&len);
    if(c <0)
    {
     printf("accept erro\n");
     return ;
    }
   epoll_add(epfd,c);

}
void recv_data(int c,int epfd)
{
  char buff[128] ={0};
  int num = recv(c,buff,127,0);
  if(num <= 0)
  {
   epoll_del(epfd,c);
   close(c);
   printf("%d close\n",c);
   return ;
  
  }
  printf("(%d),buff=%s\n",c,buff);
  send(c,"ok",2,0);

}
int socket_init();
int main()
{
    int sockfd = socket_init();
    if(sockfd == -1)
    {
      printf("socketfd init erro\n");
      exit(1);
    }
    int epfd = epoll_create(MAX);
    if(epfd == -1)
    {
     printf("epoll_create erro\n");
     close(sockfd);
     exit(1);
    }

    epoll_add(epfd,sockfd);
    struct epoll_event evs[MAX];

    while(1)
    {
     int n = epoll_wait(epfd,evs,MAX,5000);
     if(n == -1)
     {
      printf("epoll erro\n");
     }else if(n == 0)
     {
      printf("time out\n");
     }else
     {
      for(int i =0;i<n;++i)
      {
        int fd = evs[i].data.fd;
       if(evs[i].events & EPOLLIN)
       {
        if(fd == sockfd)
        {
         accept_client(fd,epfd);
        }else
        {
        
            recv_data(fd,epfd);
        
        }
       }
      
      }
     
     }
    }

    return 0;
}
int socket_init()
{

    int sockfd = socket(AF_INET,SOCK_STREAM,0);
    if(sockfd  == 0)
    {
     printf("sockfd erro\n");
     return -1;
    }
    struct sockaddr_in saddr;
    memset(&saddr,0,sizeof(saddr));
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(6001);
    saddr.sin_addr.s_addr = inet_addr("127.0.0.1");

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

}
long~w
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅谈多路复用select、epoll
m0_60007338的博客
10-20 374
多路复用select、epoll
操作系统——进程+线程+多线程并发锁+IO多路复用
weixin_45864705的博客
11-14 637
操作系统 进程 用户级线程 IO多路复用
IO多路复用详解
最新发布
qq_55882840的博客
06-09 964
epoll 全称 eventpoll，是 linux 内核实现IO多路转接/复用（IO multiplexing）的一个实现。IO多路转接的意思是在一个操作里同时监听多个输入输出源，在其中一个或多个输入输出源可用的时候返回，然后对其的进行读写操作。epoll是select和poll的升级版，相较于这两个前辈，epoll改进了工作方式，因此它更加高效。对于待检测集合select和poll是基于线性方式处理的，epoll是基于红黑树来管理待检测集合的。
WinSock I/O系列1：多路复用I/O支持多Client的实现及效率讨论
Moonset
10-19 940
1.       引言 多路复用I/O模型(select)是UNIX/LINUX用得的最多的一种I/O模型，在Windows下也 可做为一种同步I/O使用。本文给出该I/O模型处理多Client的简单（在主线程中）实现。 2.       关于select select I/O模型是一种异步I/O模型，在单线程中Linux/WinNT默认支持64个客户端套 接字。这种
I/O多路复用
Makefilehoon的博客
03-13 496
1.面试被问了很多次，今天好好总结一下：1.阻塞状态：进程的运行和阻塞：程序在执行的同时，由于期待的某些事情没有发生，为什么没有发生呢？可能是系统资源失败，等待某种操作的完成，新数据未到达或者无法新工作，则系统自动执行阻塞语句，程序由运行态变成阻塞态！2.阻塞模型：阻塞I/O模型示意图：从内核复制数据的过程：   一个输入操作包含两个阶段：         （1）.等待数据准备好。        ...
IO多路复用之epoll全面总结(必看篇)
09-15
IO多路复用技术在高并发服务器编程中扮演着至关重要的角色，因为它允许单个线程同时处理多个连接。在Linux系统中，epoll是针对IO多路复用的一种高效实现，尤其适用于大规模并发连接的场景。以下是关于epoll的详细...
io多路复用解析
12-07
IO 多路复用解析 IO 多路复用是一种高效的输入/输出（I/O）管理机制，允许单个进程同时监控多个文件描述符（FD），以便在其中某个文件描述符上发生事件时，立即响应。IO 多路复用机制广泛应用于服务器端编程、网络...
IO多路复用之select全面总结(必看篇)
01-10
IO多路复用是指内核一旦发现进程指定的一个或者多个IO条件准备读取，它就通知该进程。IO多路复用适用如下场合： （1）当客户处理多个描述字时（一般是交互式输入和网络套接口），必须使用I/O复用。 （2）当一个客户...
IO多路复用之poll全面总结(必看篇)
09-15
【IO多路复用之poll全面总结】 IO多路复用是一种高效的系统调用，用于在单个线程中管理多个文件描述符的输入/输出事件。在Linux系统中，poll是与select类似的机制，但克服了select在描述符数量上的限制。本文将对...
1.18 第六章 IO多路复用
01-18
1.18 第六章 IO多路复用
windows下select和socket配合实现多路复用技术
03-14
windows 下用c实现聊天平台需要解决的问题
windows下socket多路复用
10-31
windows下socket多路复用,select FD_SET FD_ZERO FD_ISSET FD_CLR等函数的用法，包含客户端和服务器端代码，开发环境vs2008
IO多路复用select和epoll.md
03-07
多路复用
IO多路复用图解1
08-03
在计算机编程领域，IO多路复用是一种提高服务器性能的技术，尤其在处理大量并发连接时。该技术的主要目的是通过一个单独的线程或进程来管理多个IO操作，从而避免为每个连接创建单独的线程或进程，这样可以节省资源并...
IO多路复用1
08-03
在IT领域，I/O多路复用是一种高效利用系统资源并优化并发处理的方式，尤其在服务器编程中至关重要。Linux系统提供了多种实现I/O多路复用的机制，包括select、poll和epoll。这些机制允许单个进程同时监控多个文件描述...
[IO复用] Windows IOCP的简单实现
zlllc的博客
03-05 1017
IOCP的简单使用
windows 下 select 配合socket实现多路复用
null
03-14 3592
问题描叙： 在 windows 下，用 C 语言写一个 socket 通信的程序，要求作为服务器端的程序能够实现如下功能： 检查各个用户是否在线。 能够将用户 a 的信息转发到其他用户，可以是一个，也可是多个。 select充当的角色： 在 C 编写该程序的时候遇到这么一个问题，服务器处理信息时是一个循环：a，创建一个新的 socket 然后监听信息；b，处理信息；c，然后...
redisIO多路复用
09-15
Redis利用IO多路复用技术来实现高效的网络通信。在Redis中，通过使用epoll来实现IO多路复用，将连接信息和事件放到队列中，并由事件分派器将事件分发给事件处理器。这种方式可以让单个线程高效地处理多个连接请求，减少了网络IO的时间消耗。 多路复用IO模型中，有一个内核线程不断地轮询多个socket的状态，只有当真正有读写事件发送时，才会调用实际的IO读写操作。这样可以减少资源的占用，因为只有在有读写事件发生时才会使用IO资源，同时不需要建立新的进程或线程，也无需维护这些线程和进程。 使用多路复用技术可以提高Redis的性能，特别是在内存中操作数据的速度非常快的情况下。Redis可以高效地处理多个连接请求，同时通过IO多路复用机制减少了不必要的操作，提高了系统的吞吐量和性能。 总结起来，Redis利用IO多路复用技术来实现高效的网络通信，通过epoll来实现IO多路复用，将连接信息和事件放到队列中，并由事件分派器将事件分发给事件处理器。这样可以让单个线程高效地处理多个连接请求，提高系统的吞吐量和性能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值