select函式簡解：
    selct 稱之為多路複用IO，使用它可以讓程式阻塞在select上，而非實際IO函式上.

    int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
             nfds: fd_set描述符集中 {最大描述符+1}
          readfds: 讀描述符集
         writefds: 寫描述符集
        exceptfds: 異常描述符集
          timeout: 超時時間，1)當timeout為NULL時，select
 
將阻塞到有讀或寫或異常描述符就緒才返回。
                            2)當timeout中tv_sec==0且tv_usec==0時，表示不等待，掃描一次馬上返回。
                            3)當timeout中tv_sec!=0且tv_usec!=0時，表示在指定時間內沒有就緒描述符就返回。函式返回0

注意：                         
1）正常情況下返回就緒描述符個數！
2）同時會將未就緒的描述符置零，所以select每次返回後我們都應將需用監聽的描述符重新新增到描述符集中。
3）為了可移植，當設定了超時時間時也應當從新賦值。
4
 
）使用select函式儘量不要與非系統IO混用


以下是對描述符集操作的函式:
    void FD_CLR(int fd, fd_set *set);
            從描述符集set中清除描述符fd

    int  FD_ISSET(int fd, fd_set *set);
            判斷描述符fd 是否在描述符集set中，是，返回非0；否，返回0

    void FD_SET(int fd, fd_set *set);
            將描述符fd 新增到描述符集set中

    void FD_ZERO(fd_set *set);
            對描述符集進行清零，當我們新定義一個描述集時，最好使用此函式進行清零，
 

簡單的伺服器回射程式：

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

#include "common.h"

#define SERV_PORT   10086

typedef struct sockaddr SA;

int main(void)
{
    int                 listenfd, connfd;
    struct sockaddr_in  cliaddr, servaddr;
    socklen_t           clientlen;


    if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        err_quit("socket error");
    }

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family         =   AF_INET;
    servaddr.sin_port           =   htons(SERV_PORT);
    servaddr.sin_addr.s_addr    =   htonl(INADDR_ANY);

    if (bind(listenfd, (SA *)&servaddr, sizeof(servaddr)) < 0) {
        err_quit("bind error");
    }

    if (listen(listenfd, 5) < 0) {
        err_quit("listen error");
    }


    fd_set rfds, allfd;
    int maxfd, maxi = -1;

//method one:
    //int maxfd;
    //if ((maxfd = sysconf(_SC_OPEN_MAX)) < 0) {
    //  err_sys("sysconf error");
    //} 
    //
    //int clinet[maxfd];
//-----------------------------------------------------

//method two:
//在sys/select.h中定義了一個FD_SETSIZE其表示fd_set描述符總數。
    int client[FD_SETSIZE];
//-----------------------------------------------------

    int nready;
    int i, nread;
    int sockfd;
    char buf[MAXLINE];

    FD_ZERO(&allfd);
    FD_SET(listenfd, &allfd);
    maxfd = listenfd;

    for (i=0; i<FD_SETSIZE; ++i) {
        client[i] = -1;
    }


    for ( ; ; ) {

        rfds = allfd;

        nready = select(maxfd+1, &rfds, NULL, NULL, NULL);
        if (nready < 0) {
            err_quit("select error");
        }

        if (FD_ISSET(listenfd, &rfds)) {

#ifdef DEBUG
    printf("have descriptor....\n");
#endif

            clientlen = sizeof(cliaddr);
            connfd = accept(listenfd, (SA *)&cliaddr, &clientlen);
            if (connfd < 0) {
                err_quit("accept error");
            }

            for (i=0; i<FD_SETSIZE; ++i) {
                if (client[i] < 0) {
                    client[i] = connfd;
                    break;
                }
            }

            if (i == FD_SETSIZE) {
                err_quit("too many clients");
            }

            FD_SET(connfd, &allfd);

            if (connfd > maxfd) {
                maxfd = connfd;
            }

            if (i > maxi) {
                maxi = i;
            }

            if (--nready <= 0) {
                continue;
            }
        }

        for (i=0; i<=maxi; ++i) {
            if ((sockfd = client[i]) < 0) {
                continue;
            }

            if (FD_ISSET(sockfd, &rfds)) {

#ifdef  DEBUG
    printf("fd: %d\n", sockfd);
#endif

                if ((nread = read(sockfd, buf, MAXLINE)) == 0) {
                    close(sockfd);
                    FD_CLR(sockfd, &allfd);
                    client[i] = -1;
                } else {
                    if (write(sockfd, buf, nread) != nread) {
                        err_msg("fail to write...");
                    }
                }

                if (--nready <= 0) {
                    continue;
                }
            }
        }
    }

    return EXIT_SUCCESS;
}