UNIX网络编程-Select模型学习

1、相关接口介绍

1.1 select

----------------------------------------------------------------------

#include <sys/select.h>

#include <sys/time.h>

int select(int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset, const struct timeval *timeout);

返回：准备好描述字的正数目，0—超时，-1—出错。

----------------------------------------------------------------------

参数说明：

maxfdp1: 制定要检查的描述符的个数，实际应用中传入最大描述符加1，表明要检查0到最大描述符中间的所有描述符。

readset、writeset、exceptset: 这三个参数都是值-结果参数，传入的是应用程序想让内核检查的套接字集合，传出的是内核检查过的可进行操作的套接字集合。

timeout: 超时设置，NULL表示一直等，直到有一个套接字准备好I/O时才返回，将秒和微秒两个字段都设置为0表示不等待，立即返回。

1.2 fd_set

fd_set: 存放套接字的集合。

有四个操作fd_set的宏，分别是：

void FD_ZERO(fd_set *fdset);

void FD_SET(int fd, fd_set *fdset);

void FD_CLR(int fd, fd_set *fdset);

void FD_ISSET(int fd, fd_set *fdset);

FD_SET设置文件描述符集fdset中对应于文件描述符fd的位(设置为1)

FD_CLR清除文件描述符集fdset中对应于文件描述符fd的位（设置为0）

FD_ZERO清除文件描述符集fdset中的所有位(既把所有位都设置为0)。

使用这3个宏在调用select前设置描述符屏蔽位，在调用select后使用FD_ISSET来检测文件描述符集fdset中对应于文件描述符fd的位是否被设置。

1.3 timeval

是一个表示时间的结构体：

 struct timeval
 {
     long tv_sec;   /* seconds */
     long tv_usec; /* microseconds */
 };

2、select I/O复用模型的工作流程

2.1 初始化的时候将要检查的socket放入事先定义好的fd_set集合中；

2.2通过调用select函数来获取可读、可写的socket集合；

2.3 获取集合后先检查监听socket，看是否有新的socket连接，若有，则将新的socket添加到集合中准备下一次的扫描；

2.4扫描检查过的集合，对相应的socket进行读写操作；

以下是一个使用select的简单demo，可以处理多个客户端同时跟服务端通信。

3、一个简单的Echo Server

 #include <stdio.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <strings.h>
 
 #define PORT 8080
 #define LISTENQ 5
 #define MAXLINE 1024
 #define IS_ERROR(condition) \
     if(condition) \
     { \
         printf("Error in func[%s] and line[%d]!\n", \
         __PRETTY_FUNCTION__, __LINE__); \
         return ; \
     }
 
 int main(int argc, char *argv[])
 {
     struct sockaddr_in addrSer;
     struct sockaddr_in addrCli;
     int listenSock;
     int connSock;
     int clientSock[FD_SETSIZE];
 
     int maxSock;     //the max fd
     int sumSock;     //sum of client sockets - 1
     int nCliLen;       //len of addrCli
     int nReady;       //the num of ready sockets
 
     fd_set allset;
     fd_set rset;
 
     char buf[MAXLINE];
     int nRet;
     int i;
 
     /*create listen socket*/
     listenSock = socket(AF_INET, SOCK_STREAM, );
     IS_ERROR(listenSock == -);
 
     /*bind listen port*/
     bzero(&addrSer, sizeof(addrSer));
     addrSer.sin_family      = AF_INET;
     addrSer.sin_addr.s_addr = htonl(INADDR_ANY);
     addrSer.sin_port        = htons(PORT);
     nRet = bind(
         listenSock,
         (struct sockaddr *)&addrSer,
         sizeof(struct sockaddr_in)
     );
     IS_ERROR(nRet == -);
 
     /*listen port*/
     nRet = listen(listenSock, LISTENQ);
     IS_ERROR(nRet == -);
 
     /*init*/
     maxSock = listenSock;
     sumSock = -;
 
     /*Init socket array*/
     for (i=; i<FD_SETSIZE; ++i)
     {
         clientSock[i] = -;
     }
 
     /*Init fd_set*/
     FD_ZERO(&allset);
     FD_SET(listenSock, &allset);
 
     /*request*/
     while ()
     {
         rset = allset;
         nReady = select(maxSock+, &rset, NULL, NULL, NULL);
 
         /*accept*/
         if (FD_ISSET(listenSock, &rset))
         {
             nCliLen = sizeof(addrCli);
             connSock = accept(listenSock, (struct sockaddr *)&addrCli, &nCliLen);
             for (i=; i<FD_SETSIZE; ++i)
             {
                 if (clientSock[i] < )
                 {
                     clientSock[i] = connSock;
                     break;
                 }
             }
 
             if (i == FD_SETSIZE)
             {
                 printf("too many clients!\n");
                 return ;
             }
 
             FD_SET(connSock, &allset);
 
             maxSock = (maxSock < connSock) ? connSock : maxSock;
             sumSock = (sumSock < i) ? i : sumSock;
 
             if (--nReady <= )
             {
                 continue;
             }
         }
 
         /*send and recv*/
         for (i=; i<=sumSock; ++i)
         {
             if (clientSock[i] < )
             {
                 continue;
             }
 
             if (FD_ISSET(clientSock[i], &rset))
             {
                 nRet = recv(clientSock[i], buf, MAXLINE, );
 
                 if (nRet ==  || nRet == -)
                 {
                     printf("read sock %d err, nRet = %d!\n", clientSock[i], nRet);
                     close(clientSock[i]);
                     FD_CLR(clientSock[i], &allset);
                     clientSock[i] = -;
                 }
                 else if (- == send(clientSock[i], buf, nRet, ))
                 {
                     printf("write sock %d err!\n", clientSock[i]);
                     close(clientSock[i]);
                     FD_CLR(clientSock[i], &allset);
                     clientSock[i] = -;
                 }
 
                 if (--nReady <= )
                 {
                     break;
                 }
             } //if (FD_ISSET(clientSock[i], &rset))
         } //for (i=0; i<=sumSock; ++i)
     } //while(1)
 
     return ;
 }