I/O复用-select

I/O复用

I/O复用的功能就是同时监听多个文件描述符，这样的话程序性能就能得到大大提升。通常，网络程序在下列情况下需要使用I/O复用技术：

• 服务端程序要同时处理多个socket。
• 服务端程序要同时处理用户输入和网络连接。
• TCP服务器要同时处理监听socket和连接socket。
• 服务器要同时处理TCP请求和UPD请求。
• 服务器要同时监听多个端口，或者处理多种服务。
  与多进程和多线程技术相比，I/O多路复用技术的最大优势是系统开销小，系统不必创建进程/线程，也不必维护这些进程/线程，从而大大减小了系统的开销。
  Linux下实现I/O复用的系统调用主要有select、poll和epoll现在我们来看看select。

select

作用：
用来让我们的程序监视多个文件句柄的状态变化。程序会停在select这里等待，知道被监视的文件句柄有一个或多个发生了状态变化。而文件句柄，其实就是一个整数，最熟悉的句柄是0（标准输入）、1（标准输出）、2（标准错误输出）。对应文件的stdin、stdout、stderr。监听用户感兴趣的文件描述符上的可读、可写和异常等事件。

#include<sys/select.h>
int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout);

参数：
1）nfds参数指定被监听的文件描述符的总数。它通常被设置为select监听的所有文件描述符中的最大值加1，因为文件描述符是从0开始计数。
2）readfds、wrutefds和exceptfds参数分别对应于需要检测的可读⽂件描述符的集合，可写⽂件描述符的集合及异常⽂件描述符的集合。select调用返回时，内核将修改它们来通知应用程序哪些文件文件描述符已就绪。三个参数都是fd_set结构指针类型。
fd_set结构定义在/usr/include/sys/select.h中，结构如下：

/* fd_set for select and pselect.  */
typedef struct
  {
    /* XPG4.2 requires this member name.  Otherwise avoid the name
       from the global namespace.  */
#ifdef __USE_XOPEN
    __fd_mask fds_bits[__FD_SETSIZE / __NFDBITS];
# define __FDS_BITS(set) ((set)->fds_bits)
#else
    __fd_mask __fds_bits[__FD_SETSIZE / __NFDBITS];
# define __FDS_BITS(set) ((set)->__fds_bits)
#endif
  } fd_set;

可以看到fd_set结构就只是包含了一个数组，数组的每一个元素的每一bit位都对应一个文件描述符。另外可以看到fd_set所能容纳的文件描述符个数由FD_SETSIZE指定，这就限制了select能同时处理的文件描述符的总量。
FD_SETSIZE定义在/usr/include/bits/typesizes.h中:

/* Number of descriptors that can fit in an `fd_set'.  */
#define __FD_SETSIZE        1024

这是我自己linux下的FD_SETSIZE大小
另外位操作过于频繁，所以系统给我们提供了一系列宏来访问fd_set中的位

• FD_ZERO（int fd，fd_set *fdset）//清零fdset所有位
• FD_SET（int fd，fd_set *fdset） //设置fdset的位fd
• FD_CLR（int fd，fd_set *fdset） //清除fdset的位fd
• FD_ISSET（int fd，fd_set *fdset）//测试fdset的位fd是否被设置

3）timeout参数用来设置select函数的超时时间，也就是等待时间。timeval结构类型的指针，内核需要修改它告诉应用程序select等待了多久，所以采用指针做参数。
timeval结构体定义在/usr/include/time.h中，定义如下

 struct timeval  
{  
    __time_t tv_sec;        /* Seconds. */  
    __suseconds_t tv_usec;  /* Microseconds. */  
};  

首先需要知道select提供的是微秒级的定时方式。
如果给tv_sec和tv_usec都传递0，则select立即返回。
如果timeout传递NULL，则select将一直阻塞，知道某个文件描述符就绪。

返回值：若成功，返回就绪描述符总数。若失败，返回-1并设置errno。若timeout设置的时间内没有任何文件描述符就绪，则返回0。

select缺点

（1）每次调⽤select，都需要把fd集合从⽤户态拷贝到内核态，这个开销在fd很多时会很⼤
（2）同时每次调⽤select都需要在内核遍历传递进来的所有fd，这个开销在fd很多时也很⼤
（3）刚在select参数时候也看到了，select⽀持的⽂件描述符数量太⼩了，默认是1024

实例：
select_server.c

/*************************************************************************
    > File Name: server.c
    > Author: tian
    > function:select 
    > Created Time: Fri 23 Jun 2017 12:45:42 AM PDT
 ************************************************************************/
#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/time.h>
#include<string.h>
#define __SIZE__ 64
int gfds[__SIZE__];
void usage()
{
    printf("./server [local_ip] [local_port]\n");
}
int startup(const char *ip,int port)
{
    int sock=socket(AF_INET,SOCK_STREAM,0);
    if(sock<0)
    {
        perror("socket");
        exit(2);
    }
    struct sockaddr_in server;
    server.sin_family=AF_INET;
    server.sin_port=htons(port);
    server.sin_addr.s_addr=inet_addr(ip);
    const int on=1;
    setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on));
    if(bind(sock,(struct sockaddr*)&server,sizeof(server))<0)
    {
        perror("bind");
        exit(3);
    }
    return sock;
}
int main(int argc,char* argv[])
{
    if(argc!=3)
    {
        usage();
        exit(1);
    }
    int listen_sock=startup(argv[1],atoi(argv[2]));
    if(listen(listen_sock,5)<0)
    {
        perror("listen");
        exit(4);
    }
    int i=1;
    for(;i<__SIZE__;i++)
    {
        gfds[i]=-1;              
    }
    gfds[0]=listen_sock;
    while(1)
    {
        int max_fd=-1;
        fd_set rfds;
        FD_ZERO(&rfds);
        FD_SET(listen_sock,&rfds);
        int k=0;
        for(;k<__SIZE__;k++)
        {
            if(gfds[k]>0)
            {
                if(gfds[k]>max_fd)
                    max_fd=gfds[k];
                FD_SET(gfds[k],&rfds);
            }
        }//for
        struct timeval timeout={5,0};
        switch(select(max_fd+1,&rfds,0,0,&timeout))
        {
            case -1:
            {
                perror("select");
                break;
            }
            case 0:
            {
                printf("timeout...\n");
                continue;
            } 
            default:
            {
                int j=0;
                for(;j<__SIZE__;j++)
                {
                    if(gfds[j]==-1)
                        continue;
                    else if(FD_ISSET(gfds[j],&rfds)) 
                    {
                        if(j==0)
                        {
                        struct sockaddr_in client;
                        socklen_t len=sizeof(client);
                        int new_fd=accept(listen_sock,(struct sockaddr*)&client,&len);
                        /*pid_t id=fork();
                        if(id==0)
                        {
                            close(new_fd);
                            exit(0);
                        } */
                        printf("get a new client,%s:%d\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));
                        if(new_fd<0)
                        {
                            perror("accept");
                            continue;
                        }
                        int m=1;   
                        for(;m<__SIZE__;m++)
                        {
                            if(gfds[m]==-1)
                                break;
                        }
                        if(m==__SIZE__)
                        {
                            close(new_fd);
                            printf("no\n");
                        }
                        else
                        {
                            gfds[m]=new_fd;
                        }
                        }
                        if(j!=0)
                        {//other fd ready
                            char buf[1024];
                            while(1){
                            ssize_t s=read(gfds[j],buf,sizeof(buf)-1);
                            if(s>0)
                            {
                                buf[s]='\0';
                                printf("client[%d]: %s",j,buf);
                                if(strncmp(buf,"quit",4)==0)
                                {
                                    printf("quit\n");
                                    break;
                                }
                                write(gfds[j],buf,strlen(buf));
                            }
                            else if(s==0)
                            {
                                printf("client[%d] is quit!!!\n",j);
                                close(gfds[j]);
                                gfds[j]=-1;
                                break;
                            }
                            else
                                perror("read");
                            }
                        }
                     }
                    else
                        ;
                }
            }
            break;
        }
    }//while
    close(listen_sock);
    return 0;
}