多路复用之select服务器

select函数

1、 select()函数允许进程指示内核等待多个事件(文件描述符)中的任何一个发生，并只在有一个或多个事件发生或经历一段指定时间后才唤醒它，然后接下来判断究竟是哪个文件描述符发生了事件并进行相应的处理。
2、我们可以从内核和select的关系来看：（1）传向select的参数告诉内核：
①我们所关心的描述符。
②对于每个描述符我们所关心的条件（是否读一个给定的描述符？是否想写一个给定的描述符？是否关心一个描述符的异常条件？）。
③希望等待多长时间 （可以永远等待，等待一个固定量时间，或完全不等待）。
（2）从select返回时，内核告诉我们：
①已准备好的描述符的数量。
②哪一个描述符已准备好读、写或异常条件。

通过上面的解说，我相信大家讲会进一步了解了select，接下来请看select函数。

#include <sys/types.h>
#include <sys/time.h>
#include <unistd.h>

int select (int max_fd, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

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

二、参数说明
①第一个参数：max_fd指待测试的fd的总个数，它的值是待测试的最大文件描述符加1。Linux内核从0开始到max_fd-1扫描文件描述符，如果有数据出现事件(读、写、异常)将会返回；假设需要监测的文件描述符是8,9,10，那么Linux内核实际也要监测0-7，此时真正带测试的文件描述符是0~10总共11个，即max(8,9,10)+1，所以第一个参数是所有要监听的文件描述符中最大的+1。

②中间三个参数： 中间三个参数readset、writeset和exceptset指定要让内核测试读、写和异常条件的fd集合，如果不需要测试的可以设置为NULL；这个三个描述符集存放在一个fd__set数据类型中

FD_ZERO(fd_set *fdset);//清空集合
FD_SET (int fd, fd_set *fdset);//将给定的描述符加入集合
FD_CLR (int fd, fd_set *fdset);// 将给定的描述符从文件中删除
FD_ISSET(int fd, fd_set *fdset);//判断指定描述符是否在集合中

在写代码的时候我们可以这样定义：

	fd_set  rset;
	int 	fd;

③最后一个参数：它表示指定愿意等待的条件。它的设置在一个struct timeval结构体中。

struct timeval{
	long   tv_sec；  //seconds
	long   tv_usec;  //and microseconds
	};

存在三种情况：①**•timeout == NULL** ：表示永远等待。如果捕捉到一个信号则中断此无限期等待。
②**•timeout->tv_sec == 0 && timeout->tv_usec == 0**：完全不等待，测试所有指定的描述符并立即返回。
③**•timeout- >tv—>sec!=0 | | timeout- >tv_usec! =0**:等待指定的秒数和微秒数。当指定的描述符之一已准备好，或当指定的时间值已经超过时立即返回。如果在超时时还没有一个描述符准备好，则返回值是0.

三、函数的返回值
①返回值-1表示出错，这是可能发生的，例如在所指定的描述符都没有准备好时捕捉到一个信号。
②返回值0表示没有描述符准备好。若指定的描述符都没有准备好，而且指定的时间已经超时，则发生这种情况。
③返回一个正值说明了已经准备好的描述符数，在这种情况下，三个描述符集中仍旧打开的位是对应于已经准备好的描述符位。

多路复用select实现网络socket服务器多路并发的编程

一、我们先看一下多路复用select实现网络socket服务器的流程图

二、下面是使用多路复用select实现网络socket服务器端示例代码：

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <getopt.h>
#include <stdlib.h>
#include <sys/select.h>
#include <ctype.h>
#include <libgen.h>


#define ARRAY_SIZE(x)   (sizeof(x)/sizeof(x[0]))//求数组元素的个数
static inline void msleep(unsigned long ms);

int socket_Server_init(char *listen_ip,int listen_port);
void print_usage(char *progname)
{
     printf("%s usage: \n", progname);
     printf("-p(--port): sepcify server listen port.\n");
     printf("-h(--Help): print this help information.\n");
     printf("-d(--daemon):set program running on background\n");
     return ;
}

int main (int argc, char **argv)
{

    int                 listenfd = -1;
    int                 clifd;
    struct sockaddr_in  servaddr;
    struct sockaddr_in  cliaddr;
    socklen_t           len;
    int                serv_port = 0;
    int                 ch;
    int                 rv ;
    int                 on = 1;
    int                 rdest;
    char                buf[1024];
    int                 i,j;
    int                 found;
    int                 maxfd;
    int                 daemon_run = 0;
    char                *progname = NULL;
    int                 fds_arry[1024];
    fd_set              rdset;
struct option opts[] =
{
     {"daemon",no_argument,NULL,'b'},
     {"port", required_argument, NULL, 'p'},
     {"help", no_argument, NULL, 'h'},
     {NULL, 0, NULL, 0}
};
progname = basename(argv[0]);

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

    printf("%s server start to listen on port %d\n",argv[0],serv_port);

    
    if(daemon_run)//设置进程后台运行
    {
        daemon(0,0);
    }
    
    for(i=2; i<ARRAY_SIZE(fds_arry); i++)//遍历数组
    {
        fds_arry[i]=-1;//将整个数组初始化为-1，为什么是-1；因为这个数组存放的是文件描述符，系统会生成三个文件描述符0，1，2
    }   
    fds_arry[0] = listenfd;//将第一个数组赋值为listenfd
    //一个tcp的网络链接中包含一个四元组：源ip，目的ip，源端口，目的端口

    for( ; ; )
    {
        FD_ZERO(&rdset);//清空集合
        for(i=0; i<ARRAY_SIZE(fds_arry); i++)
        {
            if( fds_arry[i] < 0)
                continue;
            maxfd = fds_arry[i]>maxfd ? fds_arry[i] : maxfd;
            FD_SET(fds_arry[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;
    }
    if( FD_ISSET(listenfd,&rdset) )//判断指定描述符是否在集合中
    {
        if( (clifd=accept(listenfd,(struct sockaddr *)NULL,NULL)))
        {
            printf("accept new client failure:%s\n",strerror(errno));
            continue;
        }

        found = 0;
        for(i=0; i<ARRAY_SIZE(fds_arry);i++)
        {
            if( fds_arry[i]< 0 )
            {
                printf("accept new client [%d] and add it into array\n",clifd);
                fds_arry[i] = clifd;
                found = 1;
                break;
            }
        }
        if(!found)
        {
            printf("accept new client [%d] but full, so refuse it\n",clifd);
            close(clifd);

        }
    }
    else
    {
        for( i=0; i<ARRAY_SIZE(fds_arry);i++)
        {
            if(fds_arry[i]<0 || !FD_ISSET(fds_arry[i],&rdset))
                continue;
            if( (rv=read(fds_arry[i],buf,sizeof(buf))) <=0)
            {
                printf("socket [%d] read failure or get disconnected\n",fds_arry[i]);
                close(fds_arry[i]);
                fds_arry[i]=-1;
            }
            else
            {
                printf("socket [%d] read get %d bytes data\n",fds_arry[i],rv);
                for(j=0; j<rv; j++)
                    buf[j]=toupper(buf[j]);
                if( write(fds_arry[i], buf , rv) <0)
                {
                    printf("socket[%d] write failure:%s\n",fds_arry[i],strerror(errno));
                    close(fds_arry[i]);
                    fds_arry[i] = -1;
                }
            }
        }
    }
}
cleanup:
    close(listenfd);
    return 0;
}

static inline void msleep(unsigned long ms)
{

    struct timeval tv;
    tv.tv_sec = ms/1000;
    tv.tv_usec = (ms%1000)*1000;
        
    select(0, NULL, NULL, NULL, &tv);
}

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("socket[%d] bind to port failure:%s\n",listenfd,strerror(errno));
        rv = -3;
        goto cleanup;
    }
      
    if( listen(listenfd,13) < 0)
    {
         printf("use bind to bind tcp socket failure:%s\n",strerror(errno));
         rv = -4;
         goto cleanup;
    }
    
cleanup:
    if(rv < 0)
        close(listenfd);
    else
        rv = listenfd;

    return rv;
}

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

1. 每次调用 select()都需要把fd集合从用户态拷贝到内核态，之后内核需要遍历所有传递进来的fd，这时如果客户端fd很多时会导致系统开销很大；
2. 单个进程能够监视的文件描述符的数量存在最大限制，在Linux上一般为1024，可以通过setrlimit()、修改宏定义甚至重新编译内核等方式来提升这一限制，但是这样也会造成效率的降低；