select函数--IO多路复用详解

最新推荐文章于 2023-03-21 19:46:38 发布
最新推荐文章于 2023-03-21 19:46:38 发布
阅读量1.5k 收藏 19
点赞数 4
分类专栏： Linux系统编程 文章标签： socket linux select linux网络编程 多路复用IO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42695024/article/details/112986439
版权

本章基于网络编程，需要学习网络编程的可以看我这篇博客：
socket编程（超简单、详细、可运行）–实现一个简单的聊天程序

什么是多路复用IO呢？

多路io：允许同时对多个I/O进行控制
可能这样说还是有点抽象，stm32下面有GPIO口，如果我需要一个LED屏幕连接在32开发板上面，是不是又很多的接线，每个接线接着板子上面的对应引脚上面，既然我们接线这个引脚了，是不是首先需要让这个引脚处于使能状态，这就是开时钟，多个引脚我们是不是要开多个引脚的时钟。配置好后我们的开发板的处理器是不是会按照需要去对这些IO口进行操作。类比Linux，socket编程里面，一个服务器端可以连接多个客户端，但是仅仅socket编程只能实现1v1，我们如何实现1 v n呢，一个客户端连接多个客户端？
在这里插入图片描述
我们可以这样理解：
在这里插入图片描述
有这样一个表，存储所有客户的标识符，根据判断那个标识符出现动作，与之进行通信。
这就需要我们要学习的第一个函数select函数。通过select函数来检测表是否准备完成，简单的说就是检测表里面有没有事件发生，比如描述符的增加，请求通信等。如果没有动作就阻塞，有动作就返回。

所以我们先来看一下表
还是以socket为例子，如果使用多路IO的话：我在服务器端，我创建了一个socket套接字，然后将服务器端socket套接字加入到表中。
当我们创建完socket后socket套接字文件描述符是3，为什么是3？因为Linux里面有三个标准文件，标准输入、标准输出、错误。他们的描述符已经占用了0、1、2所以在创建文件，文件描述符是从3开始的。
在这里插入图片描述
然后下面调用select函数，现在表里面没有异动(无动作)，那么select就阻塞了，假如现在有一个客户来连接，那么被连接的服务器端的socket文件描述符出现了动作，也就是3发生了异动，因为有人向他发出连接请求，它是不是肯定要做些什么哇，就像你向你女神表白了，你女神肯定会有所动作吧，要么拒绝你，要么答应你那么select就检测到表里面发生了动作，就会解除阻塞，然后我们就可以接受连接请求，将这个客户端的套接字文件描述符加入表中：
在这里插入图片描述
如果我设计这样一个结构：

创建表;
将服务器端套接字描述符加入表;
while(1)
{
 select;
 接收accept连接请求
 将新客户文件描述符加入到表中。
}

这样是不是表里面服务器端socket描述符出现异动select才会解除阻塞，然后接受新的客户端连接请求，再将新的客户端socket文件描述符加入表中，客户A,客户B，客户C。。。。。
是不是实现了这个结构：
在这里插入图片描述

注意：

假如现在表里面有：
0 1 2 3 4 5 6
如果现在有新的客户来连接，是不是就是7，表在判断3出现动作时候
(FD_ISSET函数)，会清除别的文件描述符，也就是表里面只剩下3，所以
我们要注意保存问题。实例中会仔细说解决方法，下面只是大概思路

我们可以创建这种结构：
*********************************************************
创建表1，表2;
将服务器端套接字描述符加入表2;
while(1)
{
 表1=表2   //每次将表2内容复制给表1
 select;//阻塞等待表异动
 FD_ISSET检测表1那个文件发生异动
 if(服务器端套接字描述符发生异动)
 {
接收accept连接请求
将新客户文件描述符加入到表2中。
 }
}
这样我们操作在表1里面，内容保存在表2里面。

接下面我们看一下需要的函数：

表操作函数

头文件：
       #include <sys/select.h>
       #include <sys/time.h>
       #include <sys/types.h>
       #include <unistd.h>

1、创建表：
   fd_set yyy;
   yyy是表名称。
   例如：fd_set lisk;
   这就创建了一个名为lisk的表。
   
2、判断表里面那个文件描述符fd发生动作：
  int FD_ISSET(int fd, fd_set *set);
  参数1：要判断的文件描述符fd
  参数2：表指针
  返回值：当描述符fd在描述符集fdset中时返回非零值，否则，返回零。

3、将文件描述符fd添加到表中：
  void FD_SET(int fd, fd_set *set);
  参数1：要添加的文件描述符fd
  参数2：表指针
  返回指：无
  
4、清除表中的描述符
   void FD_CLR(int fd, fd_set *set);
   参数1：要清除的文件描述符fd
   参数2：表指针
   返回指：无
   
5、表清0(初始化)
   void FD_ZERO(fd_set *set);
   参数：要初始化的表指针;
   返回值：无

select函数

头文件：
#include <sys/select.h>
函数：
int select(int nfds, fd_set *readfds, fd_set *writefds,
          fd_set *exceptfds, struct timeval *timeout)
参数：
    nfds : 就是你表中的文件描述符的最大值+1
    readfds: 读事件需要结构体
    writefds：写事件需要结构体
    exceptfds：异常事件需要结构体
    timeval：(结构体)
             struct timeval
            {
            long tv_sec; /* second */ //秒
            long tv_usec; /* microsecond */ //微秒
            };
            一般写NULL  无限等待，就是阻塞
            
     timeval参数解释：
     第一：若将NULL以形参传入，即不传入时间结构，就是将 select置于阻塞状态，一定等到监视文件描述符集合中某个文件描述符发生变化为止；

    第二：若将时间值设为0秒0毫秒，就变成一个纯粹的非阻塞函数，不管文件描述符是否有变化，都立刻返回继续执行，文件无变化返回0，有变化返回一个正值；

    第三：timeout的值大于0，这就是等待的超时时间，即select在timeout时间内阻塞，超时时间之内有事件到来就返回了，否则在超时后不管怎样一定返回，返回值同上述。

返回值：>0返回已经准备好并包含在fd_set结构中的描述符的总数
        =0时间限制过期则返回0
        <0出错

接下来就是示例演示，实现一个1 v n的服务器对客户端
我们进行分段演示，完整代码在最下面：
服务器端：
首先是socket创建等步骤：

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <sys/select.h>
#define PORT 55555//1024~49050
#define IP "192.168.0.103"
//一下是表部分变量
int MAX,i,flag;
fd_set lisk,lock;//创建表
int comfd;//客户端描述符
int w_flag=0;

int main()
{
  char r_buf[100]={0};
  char w_buf[100]={0};
  struct sockaddr_in addr,cli_addr;
  int len=sizeof(addr);
  int sockfd=socket(AF_INET,SOCK_STREAM,0);//IPV4,tcp
  if(sockfd==-1)
  {
    perror("error socket");
    return -1;
  
  }
 printf("连接套接字创建成功\n");
 addr.sin_family=AF_INET;
 addr.sin_port=htons(PORT);//转换
 addr.sin_addr.s_addr=inet_addr(IP);//转换
 int ret=bind(sockfd,(struct sockaddr *)&addr,sizeof(addr));
 if(ret==-1)
 {
	perror("bind error");
        return -1;
 }
  printf("绑定成功\n");
 ret=listen(sockfd,3);
 if(ret==0)
 {
   printf("监听成功\n");
 }
 else
 {
  return -1;
 }

接下来是不是accept了，如果常规的直接只使用accept函数。那么只能实现1v1。我们搭配多路IO。

//一些定义在socket创建等步骤部分，这里我拿下来
/*  全局变量
int MAX,i,flag;
fd_set lisk,lock;//创建表
int comfd;//客户端描述符
int w_flag=0;
*/
  FD_ZERO(&lock);//清空表
  FD_SET(sockfd,&lock);//像表里面添加内容
  MAX=sockfd+1;
 while(1)
 {
   lisk=lock;//备份表
   flag=select(MAX,&lisk,NULL,NULL,NULL);//调用select阻塞，产生异动后解除阻塞
   if(flag<0)
   {
     perror("select");
   }
   else
   {
      for(i=0;i<MAX;i++)
      {
        if(FD_ISSET(i,&lisk))//判断那个描述符出现异动
        {
          if(i==sockfd)//如果是server端套接字异动说明有人请求连接
          {
            comfd = accept(sockfd,(struct sockaddr *)&cli_addr,&len);//接受连接
            FD_SET(comfd,&lock);//新客户端描述符加入表
            if(comfd>MAX-1)
            {
              MAX=comfd+1;
            }
            printf("%d 已连接\n",comfd);
          }
          else//如果是服务器端描述符以外的客户端描述符异动，说明客户端请求通信或者退出
          {
            memset(r_buf,0,sizeof(r_buf));
            int col=read(i,r_buf,sizeof(r_buf));

            memset(w_buf,0,sizeof(w_buf));
            strcpy(w_buf,r_buf);

            if(col==0)//读到的字节数为0说明不是请求通信，是退出
            {
              printf("%d 已经退出\n",i);
              close(i);//关闭对应套接字文件
              FD_CLR(i,&lock);//清除表中退出的描述符
              if(i==MAX-1)//如果是最大的描述符
              {
                MAX=MAX-1;
              }
            }
            else
            { //显示接收到的内容
              printf("%d 说：%s\n",i, r_buf);
              w_flag=1;
            }
            
          }
          
        }//显示给所有用户看消息内容
      if(w_flag==1)
      {
        for(int n=4;n<MAX;n++)
        {
        write(n,w_buf,sizeof(r_buf));        
        }

      }
      w_flag=0; 
      }
   }
   
  
 }
  return 0;
}

服务器端完整代码：

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <sys/select.h>
#define PORT 55555//1024~49050
#define IP "192.168.0.103"
int MAX,i,flag;
fd_set lisk,lock;//创建表
int comfd;//客户端描述符
int w_flag=0;
int main()
{
  char r_buf[100]={0};
  char w_buf[100]={0};
  struct sockaddr_in addr,cli_addr;
  int len=sizeof(addr);
  int sockfd=socket(AF_INET,SOCK_STREAM,0);//IPV4,tcp
  if(sockfd==-1)
  {
    perror("error socket");
    return -1;
  
  }
 printf("连接套接字创建成功\n");
 addr.sin_family=AF_INET;
 addr.sin_port=htons(PORT);//转换
 addr.sin_addr.s_addr=inet_addr(IP);//转换
 int ret=bind(sockfd,(struct sockaddr *)&addr,sizeof(addr));
 if(ret==-1)
 {
	perror("bind error");
        return -1;
 }
  printf("绑定成功\n");
 ret=listen(sockfd,3);
 if(ret==0)
 {
   printf("监听成功\n");
 }
 else
 {
  return -1;
 }
  FD_ZERO(&lock);//清空表
  FD_SET(sockfd,&lock);//像表里面添加内容
  MAX=sockfd+1;
 while(1)
 {
   lisk=lock;
   flag=select(MAX,&lisk,NULL,NULL,NULL);
   if(flag<0)
   {
     perror("select");
   }
   else
   {
      for(i=0;i<MAX;i++)
      {
        if(FD_ISSET(i,&lisk))//成功返回非0值
        {
          if(i==sockfd)
          {
            comfd = accept(sockfd,(struct sockaddr *)&cli_addr,&len);
            FD_SET(comfd,&lock);
            if(comfd>MAX-1)
            {
              MAX=comfd+1;
            }
            printf("%d 已连接\n",comfd);
          }
          else
          {
            memset(r_buf,0,sizeof(r_buf));
            int col=read(i,r_buf,sizeof(r_buf));

            memset(w_buf,0,sizeof(w_buf));
            strcpy(w_buf,r_buf);

            if(col==0)
            {
              printf("%d 已经退出\n",i);
              close(i);
              FD_CLR(i,&lock);
              if(i==MAX-1)
              {
                MAX=MAX-1;
              }
            }
            else
            {
              printf("%d 说：%s\n",i, r_buf);
              w_flag=1;
            }
            
          }
          
        }
      if(w_flag==1)
      {
        for(int n=4;n<MAX;n++)
        {
        write(n,w_buf,sizeof(r_buf));        
        }

      }
      w_flag=0; 
      }
   }
   
  
 }
  return 0;
}

客户端：
客户端就写的比较简单了
read函数可以说一下：
读常规文件是不会阻塞的，不管读多少字节，read一定会在有限的时间内返回。从终端设备或网络读则不一定，如果从终端输入的数据没有换行符，调用read读终端设备就会阻塞，如果网络上没有接收到数据包，调用read从网络读就会阻塞，至于会阻塞多长时间也是不确定的，如果一直没有数据到达就一直阻塞在那里。同样，写常规文件是不会阻塞的，而向终端设备或网络写则不一定。

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <pthread.h>
#define PORT 55555
#define IP "192.168.0.103"

void * client_fun1(void * arg);
void * client_fun2(void * arg);

int sockfd=0;
char r_buf[100]={0};
char w_buf[100]={0};
int main()
{

  pthread_t pthrea_id[2]={0};
  struct sockaddr_in addr;
  int len=sizeof(addr);
  sockfd=socket(AF_INET,SOCK_STREAM,0);
  if(sockfd==-1)
  {
    perror("error socket");
    return -1;
  
  }
 printf("连接套接字创建成功\n");
 addr.sin_family=AF_INET;
 addr.sin_port=htons(PORT);
 addr.sin_addr.s_addr=inet_addr(IP);


 connect(sockfd,(struct sockaddr *)&addr,len);

 pthread_create(&pthrea_id[0],NULL,client_fun1,NULL);
 pthread_create(&pthrea_id[1],NULL,client_fun2,NULL);

 pthread_join(pthrea_id[0],NULL);
 pthread_join(pthrea_id[1],NULL);
 
 close(sockfd);
 return 0;
}
void * client_fun1(void * arg)
{
  while(1)
  {
    read(sockfd,r_buf,sizeof(r_buf));
    printf("server :%s\n",r_buf);
    memset(r_buf,0,sizeof(r_buf));
  }
}
void * client_fun2(void * arg)
{
 while(1)
 {
  scanf("%s", w_buf);
  getchar();
  write(sockfd,w_buf,sizeof(w_buf));
  memset(w_buf,0,sizeof(w_buf));
 }
}

运行截图

服务器端：
在这里插入图片描述
在这里插入图片描述

客户端：
在这里插入图片描述
可能看起来有点懵，写的比较粗糙没有优化，主要实现就是：服务器端可以看到所有人的消息，每个用户也可以看到其他用户发送的消息，类似群聊。后续会优化一下代码。

感谢评阅，感谢指正。欢迎在评论区交流或者私信我。
_…
禁止转载。

玫瑰花店
关注
  • 4
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多路复用之——select
waywt1的博客
09-26 1776
系统提供select函数来实现多路复用输入/输出模型。select系统调用是用来让我们的程序同时监视多个文件描述符的状态变化；程序会停在select这里等待，直到被监视的文件描述符有一个或多个发生了状态变化；
IO多路复用之select总结
weixin_33690367的博客
08-14 355
1、基本概念 　　IO多路复用是指内核一旦发现进程指定的一个或者多个IO条件准备读取，它就通知该进程。IO多路复用适用如下场合： 　　（1）当客户处理多个描述字时（一般是交互式输入和网络套接口），必须使用I/O复用。 　　（2）当一个客户同时处理多个套接口时，而这种情况是可能的，但很少出现。 　　（3）如果一个TCP服务器既要处理监听套接口，又要处理已连接套接口，一般也要用到I/O复用。 ...
通俗易懂说多路复用（1）select
哈尼的博客
04-10 1104
通俗易懂说多路复用（1）select1. 什么是多路复用？定义通俗易懂的举例种类2. 什么是select？背景定义3. 参考： 1. 什么是多路复用？ 定义 多路复用就是通过一种机制，可以监听多个描述符，一旦某个描述符就绪（可以读/写），就通过某种方法通知相应程序进行相应操作。 （其中，**文件描述符（fd）**是一个整数，起到一个索引的作用。进程通过fd找到fd指向的文件指针，从而对文件进行操作...
Socket网络编程之IO多路复用——select、poll、epoll详谈
weixin_42690036的博客
03-21 1518
select、poll、epoll详谈
I/O多路复用 - select、poll、epoll讲解（epoll工作图解介绍+红黑树）
m0_51429770的博客
03-07 2698
epoll的实现机制与select/poll机制完全不同。epoll是Linux内核为处理大批量文件描述符而作了改进的poll，是Linux下多路复用IO接口select/poll的增强版本，它能显著提高程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率。另一点原因就是获取事件的时候，它无须遍历整个被侦听的描述符集，只要遍历那些被内核IO事件异步唤醒而加入Ready队列的描述符集合就行了。
详解Python IO口多路复用
09-16
在Python中，可以使用select模块来实现I/O多路复用，例如`select.select()`函数，或者使用更高性能的`selectors`模块。对于网络编程，`socket`库提供了非阻塞模式的选项，配合I/O多路复用技术，能够构建高效的服务器...
python 并发编程 多路复用IO模型详解
09-18
相比之下，多路复用IO模型虽然也有类似的三个阶段，但在第一阶段，进程被`select`或`epoll`函数阻塞，而不是被具体的IO操作阻塞。这样，当一个或多个套接字准备好数据时，`select`或`epoll`会立即返回，使得进程可以...
IO多路复用之select实例
04-23
**IO多路复用之select实例详解** IO多路复用是一种高效的系统调用机制，它允许单个进程同时监控多个文件描述符（file descriptor），等待它们中的任意一个或多个准备就绪，以便进行读写操作。在Unix/Linux系统中，...
IO多路复用之poll全面总结(必看篇)
09-15
总的来说，poll是Linux系统中实现IO多路复用的重要工具，它提供了比select更灵活的事件检测机制，特别是在处理大量并发连接时，能有效地避免了文件描述符数量的限制。理解并熟练掌握poll机制，对于编写高性能的网络...
Ｉ/Ｏ多路复用(select)
编程随笔与杂谈
07-02 5166
　　在之前写过一篇五种I/O模型，感兴趣的可以去看一下，今天主要讲其中的一种，那就是I/O多路复用。因为I/O多路复用可以使一个进程同时处理多个连接。这对提高程序的性能至关重要。对于IO复用的概念与理解在上文说的挺清楚了。本文主要说实现IO复用的系统调用。 　　在linux下，实现IO复用的系统调用主要有三个：select、poll 和 epoll，下面我们将对其进行逐一讲解。 selec...
IO多路复用之select——完整代码
02-10
三种IO多路复用机制： 一：select 二：poll 三：epoll 以上三种IO多路复用的完整代码，皆可以在我的资源列表中获取下载： 资源列表：http://download.csdn.net/user/qiulanzhu
Select多路复用
weixin_38299404的博客
08-03 484
在某些场景下我们需要同时从多个通道接收数据。通道在接收数据时，如果没有数据可以接收将会发生阻塞，而select就可以同时监听一个或多个channel，直到其中一个channel准备好。 select的使用类似于switch语句，它有一系列case分支和一个默认的分支。每个case会对应一个通道的通信（接收或发送）过程。select会一直等待，直到某个case的通信操作完成时，就会执行case分支对应的语句。具体格式如下： select { case <-chan1: //
I/O多路复用及select函数解析及实例
Megustas_JJC的博客
01-23 746
概述 在进行解释之前，首先要说明几个概念： - 用户空间和内核空间 - 进程切换 - 进程的阻塞 - 文件描述符 - 缓存 I/O 用户空间与内核空间 现在操作系统都是采用虚拟存储器，那么对32位操作系统而言，它的寻址空间（虚拟存储空间）为4G（2的32次方）。操作系统的核心是内核，独立于普通的应用程序，可以访问受保护的内存空间，也有访问底层硬件设备的所有权限。为了保证用户进程不能
三种多路复用IO实现方式：select，poll，epoll的区别
Everlasting2016的博客
08-03 6255
select，poll，epoll都是IO多路复用的机制。I/O多路复用就通过一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。但select，poll，epoll本质上都是同步I/O，因为他们都需要在读写事件就绪后自己负责进行读写，也就是说这个读写过程是阻塞的，而异步I/O则无需自己负责进行读写，异步I/O的实现会负责把数据从内核拷贝到用
socket编程：select 实现多路复用
01-28 564
目录 1、socket流分类 1.1、阻塞模式 1.2、非阻塞模式 2、多路复用 2.1、select相关API介绍 2.2、select 函数相关的几个宏 2.3、select使用范例 3、select实现机制 3.1、select 模型 3.2、FD_ZERO、FD_SET、FD_ISSET用法 4、代码演练 4.1、服务器 4.2、客户端 4.3、依赖的头文件（s...
select函数的阻塞和非阻塞态理解（实践总结）
热门推荐
modi000的博客
06-15 1万+
int select(int maxfdp,fd_set *readfds,fd_set *writefds,fd_set *errorfds,struct timeval *timeout); 返回值： <0：select错误 >0：有可读写或出错文件，个数为返回值个数 0：等待超时，没有可读写或错误的文件 select函数的阻塞和非阻塞主要看最后一个参数 timeout超时时间的值，timeout的取值决定了select的三种状态： 1、timeout传........
select函数使用浅析
倚楼听风雨的博客
09-18 6152
一、函数原型及参数说明     int select(int maxfdp, fd_set *readfds, fd_set *writefds, fd_set *errorfds, struct timeval *timeout);          返回值  ： 负值：select错误，正值：某些文件可读写或出错，0：等待超时，没有可读写或错误的文件。          maxf
C：串口 select函数使用
Linux
02-21 2692
接收缓存区： /* 接收长度 */ int recv_len; /* 接收缓存区 */ char recv_buf[MAX_RECV_BUF]; 串口接收函数： void Uart1::RecvSerial(int fd) { fd_set fds; struct timeval timeout={1,0}; //select等待1秒，1秒轮询，要非阻塞就置0 int se...
IO多路复用之select函数详解
lixungogogo的博客
08-17 1万+
IO复用 　　我们首先来看看服务器编程的模型，客户端发来的请求服务端会产生一个进程来对其进行服务，每当来一个客户请求就产生一个进程来服务，然而进程不可能无限制的产生，因此为了解决大量客户端访问的问题，引入了IO复用技术。 　　即：一个进程可以同时对多个客户请求进行服务。 　　也就是说IO复用的“介质”是进程(准确的说复用的是select和poll，因为进程也是靠调用select和poll来实
io多路复用select
最新发布
07-29
IO多路复用中的select是一种常见的实现方式，它可以同时监听多个IO事件，一次系统调用就能判断所有IO的可读写状态。select函数的原型为int select(int maxfdp, fd_set *readset, fd_set *writeset, fd_set *...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值