多路複用select實現網絡socket服務器

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)) <0)
        {
            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()、修改宏定義甚至重新編譯內核等方式來提升這一限制，但是這樣也會造成效率的降低；