【Linux】I/O多路转接select

系统提供select函数来实现多路复用输入/输出模型，那为什么提供select函数？

select高效的原因

首先要知道一个概念，一次I/O分两个部分（①等待数据就绪 ②进行I/O），减少等待数据的的比重，增加I/O的比重就可以达到高效服务器的目的。
select工作原理就是减少等的比重，同时监控多个文件描述符（或者说文件句柄），一旦其中某一个进入就绪状态，就进行I/O操作。监控多个文件句柄可以达到提高就绪状态出现的概率，就可以使CPU在大多数时间下都处于忙碌状态，大大提高CPU的性能。达到高效服务器的目的。

select系统调用是用来让我们的程序监视多个文件句柄的状态变化的。程序会停在select这⾥里等待，直到被监视的文件句柄有一个或多个发⽣生了状态改变。

select函数

(1)select函数参数

• ① 参数nfds是需要监视的最⼤大的⽂文件描述符值+1；
• ② rdset,wrset,exset分别对应于需要检测的可读文件描述符的集合，可写文件描述符的集合及异常文件描述符的集合。
  注：这三个参数是输入输出参数
  输入：将要监控的文件描述符传给select
  输出：将处于就绪状态的文件描述符返回。 （所以要在每次处理完一就绪事件后要将readfds,writefds,execptfd三个参数重置）

下⾯面的宏提供了处理这三种描述词组的⽅方式:
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的全部位

• ③参数timeout为结构timeval，用来设置select()的等待时间，其结构定义如下：
  
  如果参数timeout设为：
  NULL：则表示select（）没有timeout，select将一直被阻塞，直到某个文件描述符上发生了事件。
  0：timeout = {0,0} :仅检测描述符集合的状态，然后立即返回，并不等待外部事件的发生。
  特定的时间值：如果在指定的时间段里没有事件发生，select将超时返回。

(2)函数返回值：

执行成功则返回.文件描述词状态已改变的个数
如果返回0代表在描述词状态改变前已超过timeout时间，没有返回；
当有错误发生时则返回-1，错误原因存于errno，

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由用户态拷贝到内核态，这样的开销会很大。
2. 实现select服务器，内部要不断对文件描述符集fd进行循环遍历，当fd很多时，开销也很大。
3. select能监控文件描述符的数量有限，一般为1024。（sizeof（fd_set） * 8 = 1024（fd_set内部是以位图表示文件描述符））

select模型的服务器

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


int array_fds[1024];


int startup(char* ip, short port)
{
    int sock = socket(AF_INET,SOCK_STREAM,0);
    if(sock < 0)
    {
        perror("socket");
        exit(2);
    }
    int opt = 1;
    setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));

    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(port);
    local.sin_addr.s_addr = inet_addr(ip);
    //bind
    if(bind(sock,(struct sockaddr*)&local,sizeof(local)) < 0)
    {
        perror("bind");
        exit(3);
    }
    //listen
    if(listen(sock,10) < 0)
    {
        perror("listen");
        exit(4);
    }
    return sock;

}
int main(int argc,char* argv[])
{
    if(argc != 3)
    {
        printf("Usage:%s [local_ip] [local_port]\n",argv[0]);
        return 1;
    }
    int listen_sock  = startup(argv[1],atoi(argv[2]));
    int maxfds = 0;//select第一个参数
    fd_set rfds;
    int array_size = sizeof(array_fds)/sizeof(array_fds[0]);
    array_fds[0] = listen_sock;

    //初始化array_fds
    int i = 1;
    for(;i < array_size;++i)
    {
        array_fds[i] = -1;
    }

    while(1)
    {
        struct timeval timeout = {0,0};//非阻塞式等待，NULL为阻塞式的等待
        FD_ZERO(&rfds);
        maxfds = -1;
        for(i = 0; i < array_size;++i)
        {
            if(array_fds[i] > 0)
            {
                FD_SET(array_fds[i],&rfds);
                if(array_fds[i] > maxfds)//设置maxfds(select第一个参数)
                    maxfds = array_fds[i];
            }
        }

        switch(select(maxfds+1,&rfds,NULL,NULL,/*&timeout*/NULL ))
        {
        case 0:
            printf("timeout....\n");
            break;
        case -1:
            perror("select");
            break;
        default://success
            {
                int j = 0;
                for(; j < array_size;++j)
                {   
                    if(array_fds[j] < 0)
                        continue;
                    if(j == 0 && FD_ISSET(array_fds[j],&rfds))
                    {
                        struct sockaddr_in client;
                        socklen_t len = sizeof(client);
                        int new_fd = accept(array_fds[j],\
                                (struct sockaddr*)&client,&len);
                        if(new_fd <0)
                        {
                            perror("accept");
                            continue;
                        }
                        else
                        {
                            printf("get a client:%s, %d\n",\
                            inet_ntoa(client.sin_addr),\
                            ntohs(client.sin_port));
                            int k = 1;
                            for(; k < array_size;++k)
                            {
                                if(array_fds[k] < 0 )
                                {
                                    array_fds[k] = new_fd;
                                    break;
                                }
                            }
                            if(k == array_size)//表示没有可用的文件接口
                                close(new_fd);
                        }
                    }
                    else if(j != 0 && FD_ISSET(array_fds[j],&rfds))
                    {
                        char buf[1240];
                        ssize_t s = read(array_fds[j],\
                                    buf,sizeof(buf)-1);
                        if(s >0)
                        {
                            buf[s] = 0;
                            printf("client say#:%s\n",buf);
                        }
                        else if(s == 0)
                        {
                            printf("client quit\n");
                            close(array_fds[j]);
                            array_fds[j] = -1;//必须修改掉           
                        }
                        else 
                        {
                            perror("read");
                            close(array_fds[j]);

                        }
                    }
                }
            }
            break;
        }

    }
    return 0;
}