UNIX实现IO多路复用之使用select函数实现网络socket服务端

一，前言

UNIX下存在五种网络模型，分别是：同步阻塞IO，同步非阻塞IO，信号驱动IO，异步IO和今天要介绍的IO多路复用。

那么IO多路复用解决的问题是什么呢？

我们知道在UNIX下的很多函数都是阻塞的,阻塞是指IO操作在没有接收完数据或者没有得到结果之前不 会返回，需要彻底完成后才返回到用户空间；假设我们现在面临这样一个问题：我们需要在一个程序里要查看按键是否要按下，同时他还要从串口里读取数据进行处理，也要处理网络上来的数据，如果只是普通的利用三个read调用来解决，如果按键这时没按下(即数据没有准备好)read()系统调用不会返回在那，即使现在串口或网 络socket有数据到来也没法处理，我们可以采用多线程的方式来做这个问题，但是并比较耗内存和cpu，所以今天我们来浅浅的学习一下IO多路复用模型下的select函数吧！

二，关于select

优点：

基于select的I/O复用模型的是单进程执行可以为多个客户端服务，这样可以减少创建线程或进程所需要的CPU时间片或内存资源的开销；此外几乎所有的平台上都支持select()，其良好跨平台支持

缺点：

1. 每次调用 select()都需要把fd集合从用户态拷贝到内核态，之后内核需要遍历所有传递进来fd，这时如果客户端fd很多时会导致系统开销很大；

2. 单个进程能够监视的文件描述符的数量存在最大限制，在Linux上一般为1024，可以通过setrlimit()、修改宏定义甚至重 新编译内核等方式来提升这一限制，但是这样也会造成效率的降低；

三，select（）函数的用法

#include <sys/select.h>
#include <sys/time.h>
struct timeval
{
 long tv_sec; //seconds
 long tv_usec; //microseconds
};


FD_ZERO(fd_set* fds) //清空集合
FD_SET(int fd, fd_set* fds) //将给定的描述符加入集合
FD_ISSET(int fd, fd_set* fds) //判断指定描述符是否在集合中
FD_CLR(int fd, fd_set* fds) //将给定的描述符从文件中删除 
int select(int max_fd, fd_set *readset, fd_set *writeset, fd_set *exceptset, struct timeval *timeout);

说明： select监视并等待多个文件描述符的属性发生变化，它监视的属性分3类，分别readfds(文件描述符有数据到来可读)、writefds(文件描述符可写)、和exceptfds(文件描述符异常)。调用后select函数会阻塞，直到有描述符就绪（有数据可读、可写、或者有错误异常），或者超时（timeout 指定等待时间）发生函数才返回。当select()函数返回后，可以通过遍历 fdset，来找到
究竟是哪些文件描述符就绪。
 

注意：
1. select函数的返回值是就绪描述符的数目，超时时返回0，出错返回-1；
2. 第一个参数max_fd指待测试的fd的总个数，它的值是待测试的最大文件描述符加1。Linux内核从0开始到max_fd-1扫描文件描述符，如果有数据出现事件(读、写、异常)将会返回；假设需要监测的文件描述符是8,9,10，那么Linux内核实际也要监测0~7，此时真正带测试的文件描述符是0~10总共11个，即max(8,9,10)+1，所以第一个参数是所有要监听的文件描述符中最大的+1。
3. 中间三个参数readset、writeset和exceptset指定要让内核测试读、写和异常条件的fd集合，如果不需要测试的可以设置为NULL；
4. 最后一个参数是设置select的超时时间，如果设置为NULL则永不超时；需要注意的是待测试的描述集总是从0， 1， 2， ...开始的。 所以， 假如你要检测的描述符为8， 9， 10， 那么系统实际也要监测0， 1， 2， 3， 4， 5， 6, 7， 此时真正待测试的描述符的个数为11个， 也就是max（8， 9， 10） + 1

在Linux内核有个参数__FD_SETSIZE定义了每个FD_SET的句柄个数中，这也意味着select所用到的FD_SET是有限的，也正是这个原因select()默认只能同时处理1024个客户端的连接请求：

 /linux/posix_types.h:
 #define __FD_SETSIZE 1024

四，举例（代码含详细注释）

下面使用select()多路复用实现的服务器端示例：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include <time.h>
#include <pthread.h>
#include <getopt.h>
#include <libgen.h>
#include <sys/types.h> 
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))//定义一个ARRAY_SIZE的宏用来描述元素个数=整个数组的大小÷第一个元素的大小；

static inline void msleep(unsigned long ms);//定义msleep函数；
static inline void print_usage(char *progname);//定义print_usage函数;
int socket_server_init(char *listen_ip, int listen_port);//定义socket_server_init函数；
int main(int argc, char **argv)
{
    int         listenfd, connfd;
    int         serv_port = 0;
    int         daemon_run = 0;
    char       *progname = NULL;
    int         opt;
    fd_set      rdset;  //rdset是一个存放集合的地方；
    int         rv;
    int         i, j;
    int         found;
    int         maxfd=0;
    char        buf[1024];
    int         fds_array[1024];//fds_array是一个保存客户端fd的数组；
    struct      option long_options[] ={ 
                                           {"daemon", no_argument, NULL, 'b'},
                                           {"port", required_argument, NULL, 'p'},
                                           {"help", no_argument, NULL, 'h'},
                                           {NULL, 0, NULL, 0}
                                       }; progname = basename(argv[0]);

    while ((opt = getopt_long(argc, argv, "bp:h", long_options, NULL)) != -1)
    { 
        switch (opt)
        { 
            case 'b':
            daemon_run=1;
            break;
            case 'p':
            serv_port = atoi(optarg);
            break;
            case 'h': 
            print_usage(progname);
            return EXIT_SUCCESS;
            default:
            break;
        } 
    } 
    if( !serv_port )
    { 
        print_usage(progname);
        return -1;
    }
    if( (listenfd=socket_server_init(NULL, serv_port)) < 0 )
    {
        printf("ERROR: %s server listen on port %d failure\n", argv[0],serv_port);
        return -2;
    }
    printf("%s server start to listen on port %d\n", argv[0],serv_port);

    if( daemon_run )
    {
       daemon(0, 0);
    }//是否要丢到后台运行；
    for(i=0; i<ARRAY_SIZE(fds_array) ; i++) //遍历整个数组；
    {
        fds_array[i]=-1;
    }
    fds_array[0] = listenfd;//将监听事件发生的客户端文件描述符写入集合；
    for ( ; ; )//死循环，相当于while(1);
    {
        FD_ZERO(&rdset);//将集合清零；
        for(i=0; i<ARRAY_SIZE(fds_array) ; i++)//遍历整个循环；
        {
            if( fds_array[i] < 0 )
            continue;
            maxfd = fds_array[i]>maxfd ? fds_array[i] : maxfd;
            FD_SET(fds_array[i], &rdset);//将满足条的文件描述符加入集合；
        }

       
        rv = select(maxfd+1, &rdset, NULL, NULL, NULL);//调用select函数。
        if(rv < 0)
        {
            printf("select failure: %s\n", strerror(errno));//出错处理；
            break;
        }
        else if(rv == 0)
        {
            printf("select get timeout\n");//超时处理；
            continue;
        }
       /* rv>0时有两种事件操作，第一是监听，第二是对已连接的客户端进行操作*/
        if ( FD_ISSET(listenfd, &rdset) )//判断指定listenfd是否在集合中；
        {
            if( (connfd=accept(listenfd, (struct sockaddr *)NULL, NULL)) < 0)//若accept失败；
            {
                printf("accept new client failure: %s\n", strerror(errno));
                continue;
            }
            found = 0;
            /*accept连接成功后，对fds_array数组中还未被占用的位置将connfd加入数组*/
            for(i=0; i<ARRAY_SIZE(fds_array) ; i++)
            {
                if( fds_array[i] < 0 )
                {
                    printf("accept new client[%d] and add it into array\n", connfd );
                    fds_array[i] = connfd;
                    found = 1;
                    break;
                }
            }
            if( !found )
            {
                printf("accept new client[%d] but full, so refuse it\n", connfd);
                close(connfd);
            }
        }
        else//对已连接的客户端进行操作；
        {
            for(i=0; i<ARRAY_SIZE(fds_array); i++)
            {
                if( fds_array[i]<0 || !FD_ISSET(fds_array[i], &rdset) )//文件描述符小于0或者文件描述符不在集合内的就结束本次循环；
                continue;
                if( (rv=read(fds_array[i], buf, sizeof(buf))) <= 0)//读入失败；
                {
                    printf("socket[%d] read failure or get disconncet.\n", fds_array[i]);//出错处理；
                    close(fds_array[i]);
                    fds_array[i] = -1;
                }
                else//读入成功的；
                {
                    printf("socket[%d] read get %d bytes data\n", fds_array[i], rv);
 /* convert letter from lowercase to uppercase */
                    for(j=0; j<rv; j++)//read的返回值是写入buf的字节数；
                    buf[j]=toupper(buf[j]);
                    if( write(fds_array[i], buf, rv) < 0 )//写操作；
                    {
                        printf("socket[%d] write failure: %s\n", fds_array[i], strerror(errno));
                        close(fds_array[i]);
                        fds_array[i] = -1;
                    }
                }
            }
        }
    }
CleanUp:
    close(listenfd);
    return 0;
}

/*linux下没有毫秒级的延时，采用这个函数实现毫秒级别的延时；*/
static inline void msleep(unsigned long ms)
{
    struct           timeval tv;
    tv.tv_sec   =    ms/1000;//s=ms÷1000；
    tv.tv_usec  =   (ms%1000)*1000;//（us=ms%1000）*10000； 
    select(0, NULL, NULL, NULL, &tv);
}

static inline void print_usage(char *progname)
{
    printf("Usage: %s [OPTION]...\n", progname);
 
    printf(" %s is a socket server program, which used to verify client and echo back string from it\n",progname);
    printf("\nMandatory arguments to long options are mandatory for short options too:\n");
 
    printf(" -b[daemon ] set program running on background\n");
    printf(" -p[port ] Socket server port address\n");
    printf(" -h[help ] Display this help information\n");
 
    printf("\nExample: %s -b -p 8900\n", progname);
    return ;
}

/*服务端监听客户端函数；*/
int socket_server_init(char *listen_ip, int listen_port)
{
    struct sockaddr_in     servaddr;
    int                    rv = 0;
    int                    on = 1;
    int                    listenfd;
    
    if ( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        printf("Use socket() to create a TCP socket failure: %s\n", strerror(errno));
        return -1;
    }
 
    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET; 
    servaddr.sin_port = htons(listen_port);
    if( !listen_ip ) 
    {
        servaddr.sin_addr.s_addr = htonl(INADDR_ANY); 
    }
    else 
    {
        if (inet_pton(AF_INET, listen_ip, &servaddr.sin_addr) <= 0)
        {
            printf("inet_pton() set listen IP address failure.\n");
            rv = -2;
            goto CleanUp;
        }
    }
    if(bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0)
    {
        printf("Use bind() to bind the TCP socket failure: %s\n", strerror(errno));
        rv = -3;
        goto CleanUp;
    }
    if(listen(listenfd, 13) < 0)
    {
        printf("Use bind() to bind the TCP socket failure: %s\n", strerror(errno));
        rv = -4;
        goto CleanUp;
    }
CleanUp:
    if(rv<0)
    close(listenfd);
    else
    rv = listenfd;
    return rv;
}