select函数的介绍和使用

我们所使用的I/O模型一共有五种。

分别为阻塞I/O，非阻塞I/O，I/O复用，信号驱动I/O，异步I/O。

所谓I/O复用就是指管理多个I/O文件描述符，一般会使用(select，poll，epoll)3个函数中的一个来实现I/O复用。

下面就介绍一下其中的select

int select(int nfds, fd_set *readfds, fd_set *writefds,

fd_set *exceptfds, struct timeval *timeout);

void FD_CLR(int fd, fd_set *set);

int  FD_ISSET(int fd, fd_set *set);

void FD_SET(int fd, fd_set *set);

void FD_ZERO(fd_set *set);

select的5个参数：

第一个参数是当前管理的所有文件描述符的最大值加1

因为在select中采用的是轮询的机制，输入参数是不包含的。

你可以这样理解:   for(fd = 0; fd<maxfd+1 ; fd++)

[顺带一提: 文件描述符0是stdin，1是stdout，2是stderr]

第二个参数是读集合

你要管理哪些文件描述符的读的事件，就把它放到fd_set *readfds结构体中(用FD_SET()函数)；

第三个参数是写集合

同样，要管理哪些文件描述符的写的事件，就把它放到fd_set *readfds结构体中(用FD_SET()函数)；

第四个参数是异常集合

就是监视异常事件的发生

第五个参数是超时时间的设置

struct timeval {

long tv_sec; 秒

long tv_usec; 毫毛
}

不要忽略这也是一个输入输出参数(即该参数会被函数改变)，如果是一个循环，那么每次都要重新赋值该参数。

注意：select中除了第一个参数都是输入输出参数，即放在这几个位置的值都会被改变

读，写，异常集合输入参数是要监视的集合，使用完select后会变成有事件发生的事件集合，而timeout会被select函数减少

第1个参数必须设置正确(在window系统中可以不设置，但在linux系统中必须设置)

第2,3,4个参数若设置为NULL，表示不关心任何事件，若不关心其中的一种事件，可将其设置为NULL。

顺带提一下[int fileno(FILE *stream);]，这个函数可以用来取得参数stream指定的文件流所使用的文件描述符。

用select函数实现并发服务器并发数量受两方面限制

1.最大文件描述符(系统参数)

可在LINUX终端直接输入 ulimit -n 查看，用 ulimit -n [数值] 改变参数

或者在程序中用setrlimit 函数改变(注意：setrlimit 函数只能改变当前进程的最大文件描述符)

2.select中的fd_set集合容量FD_SETSIZE，不容易改变，需要重新编译内核

下面是select实现的(可实现多个客户端连接)回射服务器代码

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

 void myerr(char *m)
 {
     perror(m);
     exit();
 }

 int count = ;
 int main()
 {
     int listenfd;
     if((listenfd = socket(AF_INET, SOCK_STREAM, )) < )
         myerr("socket error");

     int on = ;
         if(setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < )
                 myerr("setsockopt error");

     struct sockaddr_in servaddr;
     memset(&servaddr, , sizeof(servaddr));
     servaddr.sin_port = htons();
     servaddr.sin_family = AF_INET;
     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

     if(bind(listenfd, (struct sockaddr*) &servaddr, sizeof(servaddr)) < )
         myerr("bind error");

     if(listen(listenfd, SOMAXCONN) < )
         myerr("listen error");

     int i, maxi=, conn, ret, maxfd, nready;
     char recvbuf[] = "";
     struct sockaddr_in peeraddr;
     int connfd[FD_SETSIZE];
     for(i=; i<FD_SETSIZE; i++)
         connfd[i] = -;
     socklen_t peerlen = sizeof(peeraddr);

     maxfd = listenfd;
     fd_set allset, rset;
     FD_ZERO(&allset);
     FD_ZERO(&rset);
     FD_SET(listenfd, &allset);

     for(;;)
     {
         rset = allset;
         sleep();
         nready = select(maxfd+, &rset, NULL, NULL, NULL);
         if(nready == -)
         {
             if(errno == EINTR)
                 continue;
             myerr("select");
         }
         if(FD_ISSET(listenfd, &rset))
         {
             if((conn = accept(listenfd, (struct sockaddr *)&peeraddr, &peerlen)) < )
                 myerr("accept error");
             for(i=; i<FD_SETSIZE; i++)
             {
                 if(connfd[i] == -)
                 {
                     connfd[i] = conn;
                     if(i > maxi)
                         maxi = i;
                     break;
                 }
             }
         //    count++;
         //    printf("%d\n", count);
             if(i == FD_SETSIZE)
             {
                 fprintf(stderr, "too many clients\n");
                 exit();
             }
             printf("ip: %s  port: %d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
             FD_SET(conn, &allset);
             if(conn > maxfd)
                 maxfd = conn;
             if(--nready <= )
                 continue;
         }
         for(i=; i<=maxi; i++)
         {
             if(connfd[i] == -)
                 continue;
             conn = connfd[i];

             if(FD_ISSET(conn, &rset))
             {
                 memset(recvbuf, , sizeof(recvbuf));
                 ret = read(conn, recvbuf, sizeof(recvbuf));
                 if(ret == )
                 {
                     printf("client close\n");
                     close(conn);
                     connfd[i] = -;
                     while(connfd[maxi] == -)
                     {
                         maxi --;
                         if(maxi == )
                             break;
                     }
                     FD_CLR(conn, &allset);
                     continue;
                 }
                 write(conn, recvbuf, ret);
                 fputs(recvbuf, stdout);
                 if(--nready <= )
                     break;
             }
         }
     }
     close(listenfd);
     return ;
 }