I/O多路转接之select

系统提供select函数来实现多路复⽤用输入/输出模型。select系统调用是用来让我们的程序监视 多个文件句柄的状态变化的。程序会停在select这里等待，直到被监视的文件句柄有一个或 多个发生了状态改变。关于文件句柄（socket），其实就是一个整数，我们最熟悉的句柄是0、1、2三 个，0是标准输入，1是标准输出，2是标准错误输出。0、1、2是整数表⽰示的，对应的FILE * 结构的表⽰示就是stdin、stdout、stderr。

 

I （状态）那个文件描述符上的读事件就绪，O （状态）那个文件描述符上的写事件就绪。

 

select函数

 

参数nfds是需要监视的最大的文件描述符值+1；

readfds,writefds,exceptfds000000

分别对应于需要检测的可读文件描述符的集合，可写文件描述符的集 合及异 常文件描述符的集合,都是输入输出型参数。

例如：fd_set 问件描述符集，设置readfds 说明 select 当前关心那些文件描述上的读事件，返回时，readfds 值表名有哪些文件描述符上的读事件已经就序；  

 

下面的宏提供了处理这三种描述词组的方式:

 

FD_CLR(inr fd,fd_set* set)；用来清除描述词组set中相关fd 的位

FD_ISSET(int fd,fd_set *set)；用来测试描述词组set中相关fd 的位是否为真

FD_SET（int fd,fd_set*set）；⽤用来设置描述词组set中相关fd的位

FD_ZERO（fd_set *set）；用来清除描述词组set的全部位

 

struct timeval结构用于描述一段时间长度，如果在这个时间内，需要监视的描述符没有事件 发⽣生则函数返回，返回值为0。

参数timeout为结构timeval，⽤用来设置select()的等待时间，其结构定义如下：

 

 

 

如果参数timeout设为： NULL：则表⽰示select（）没有timeout，select将⼀一直被阻塞，直到某个⽂文件描述符上发⽣生了 事件。

0：仅检测描述符集合的状态，然后⽴立即返回，并不等待外部事件的发⽣生。

特定的时间值：如果在指定的时间段⾥里没有事件发⽣生，select将超时返回。

 

函数返回值：

执⾏行成功则返回⽂文件描述词状态已改变的个数

如果返回0代表在描述词状态改变前已超过timeout时间，没有返回；

当有错误发⽣生时则返回-1，错误原因存于errno，此时参数readfds，writefds，exceptfds和 timeout的值变成不可预测。

错误值可能为：

EBADF ⽂文件描述词为⽆无效的或该⽂文件已关闭

EINTR 此调⽤用被信号所中断 EINVAL 参数n 为负值。

ENOMEM 核⼼心内存不足

 

 

理解select模型：

理解select模型的关键在于理解fd_set,为说明方便，取fd_set长度为1字节，fd_set中的每⼀一bit 可以对应⼀一个⽂文件描述符fd。则1字节长的fd_set最⼤大可以对应8个fd。

（1）执行fd_set set; FD_ZERO(&set);则set用位表示是0000,0000。

（2）若fd＝5,执行FD_SET(fd,&set);后set变为0001,0000(第5位置为1)

（3）若再加入fd＝2，fd=1,则set变为0001,0011

（4）执行select(6,&set,0,0,0)阻塞等待

（5）若fd=1,fd=2上都发生可读事件，则select返回，此时set变为0000,0011。

注意：没有事件 发生的fd=5被清空。 　

 

基于上面的讨论，可以轻松得出select模型的特点： 　　

（1)可监控的文件描述符个数取决与sizeof(fd_set)的值。我这边服务 器上sizeof(fd_set)＝ 512，每bit表示个文件描述符，则我服务器上支持的最大文件描述符是512*8=4096。据说 可调，另有说虽 然可调，但调整上限受于编译内核时的变量值。 （2）将fd加入select监控集的同时，还要再使用一个数据结构array保存放到select监控集 中的fd，一是用于再select 返回后，array作为源数据和fd_set进行FD_ISSET判断。二是select 返回后会把以前加入的但并无事件发生的fd清空，则每次开始 select前都要重新从array取得fd 逐一加入（FD_ZERO最先），扫描array的同时取得fd最大值maxfd，用于select的第一个 参 数。 　　

（3）可见select模型必须在select前循环array（加fd，取maxfd），select返回后循环array （FD_ISSET判断是否有时间发生）。

 

 

 

select缺点：

（1）每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多时会很大

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

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

 

 

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

int fds[64];
const int back_log=5;
void usage(char* argv)
{ 
  printf("%s:[ip][port]
",argv);
}
int start_up(char* ip,int port)  //创建一个套接字，绑定，检测服务器
{
    //sock
  int sock=socket(AF_INET,SOCK_STREAM,0);   //创建套接字
  if(sock<0)
  {
      perror("sock");
      exit(0);
  }
  struct sockaddr_in local;       //本地 sockaddr_in 结构体
  local.sin_port=htons(port);
  local.sin_family=AF_INET;
  local.sin_addr.s_addr=inet_addr(ip);

  //bind
  if(bind(sock,(struct sockaddr*)&local,sizeof(local))<0)  //绑定
  {
      perror("bind");
      exit(1);
  }
  //listen
  if(listen(sock,back_log)<0)     //检测服务器
  {
      perror("sock");
      exit(1);
  }
  return sock;
}
int main(int argc,char* argv[])                         
{
    if(argc!=3)     //检测参数个数是否正确
    {
        usage(argv[0]);
        exit(1);
    }
    int port=atoi(argv[2]);
    char* ip=argv[1];


    int done=0;
    int new_sock=-1;
    int listen_sock=start_up(ip,port);      //创建一个绑定了本地 ip 和端口号的套接字描述符
    struct sockaddr_in client;
    socklen_t len=sizeof(client);

    int max_fd = -1;       //文件描述符最大值
    fd_set _reads;    //_reads文件描述符集
    fd_set _writes;   //_writes文件描述符集

    int i=0;
    int fds_num=sizeof(fds)/sizeof(fds[0]);     //文件描述符的数组
    for(i=0;i<fds_num;i++)                      //初始化文件描述符数组
    {
       fds[i]=-1;
    }
    fds[0]=listen_sock;    //将listen_sock写入文件描述符数组之中

    while(!done)
    {
        FD_ZERO(&_reads);   //每次循环把_reads,_writes初始化（输入、输出 参数）
        FD_ZERO(&_writes);
        struct timeval _timeout={5,0};  //设置等待时间
        for(i=0;i<fds_num;i++)
        {
            if(fds[i]>0)
            {
                FD_SET(fds[i],&_reads);   //select要监听的套接字描述符 加到文件描述符集中
                if(fds[i]>max_fd)
                {
                    max_fd=fds[i];
                }
            }
        }
        switch(select(max_fd+1,&_reads,&_writes,NULL,&_timeout))  //_reads,_writes,_timeout 输入，输出参数
        {
            case 0:                  //select输出0 ，表示监听超时
                printf("timeout
");
                break;
            case -1:                 //select出错
                perror("select");
                break;
            default:                 //_reads（输入输出型参数）文件描述符集中有 OK 的
              {
                for(i=0;i<fds_num;i++)
                {
                  if(fds[i]==listen_sock&&FD_ISSET(fds[i],&_reads)) //select 关注的迎宾 socket 描述符已就绪
                  {
                    new_sock=accept(listen_sock,(struct sockaddr*)&client,&len);  //创建新的 socket 描述符

                    if(new_sock<0)
                    {
                        perror("new_sock");
                        continue;
                    }
                    printf("get connection...%ld
",new_sock);
                    for(i=0;i<fds_num;i++)   //将新的 socket 描述符安排在数组中未被占用的最小位置
                    {
                        if(fds[i]==-1)
                        {
                            fds[i]=new_sock;
                            break;
                        }
                    }
                    if(i==fds_num)   //文件描述符个数已达到最大值则忽略
                    {
                        close(new_sock);
                    }
                  }

                else if(fds[i]>0&&FD_ISSET(fds[i],&_reads))  //select 关注的普通的 socket 描述符
                {
                    char buf[1024];
                    ssize_t _s=read(fds[i],buf,sizeof(buf)-1);
                    if(_s>0)
                    {
                        buf[_s]='';
                        printf("%s
",buf);
                    }
                    else if(_s==0)
                    {
                        fds[i] = -1;     //在 _read 文件描述符数组中去掉
                        printf("client closed
");
                    }
                    else
                    {
                        perror("read");
                    }
               }
               else
               {}
               }
            }
        }
    }
return 0;
}