多路复用之select（）

该函数允许进程指示内核等待多个时间中的任何一个发送，并只有在有一个或者多个时间发生或经历一段指定的时间后才唤醒。函数原型如下：

#include<sys/select.h>
#include<sys/time.h>
int select(int max_fd,fd_set *readset,fd_set *writeset,fd_set *acceptset, struct timeval *timeout)
	返回值：就绪描述符的数目，超时返回0，出错返回-1

	函数参数介绍如下：
	（1）第一个参数max_fd指定待测的测试的描述字个数，它的值为待测试的最大描述字+1，Linux内核从0开始到max_fd-1扫描文件描述符，如果有数据出现事件(读、写、异常)将会返回；假设需要监测的文件描述符是8,9,10，那么Linux内核实际也要监测0~7，还有8，9，10总共11个，即max(8,9,10)+1，所以第一个参数是所有要监听的文件描述符中最大的+1。
	（2）中间的三个参数readset,writeset,和ecceptset指定我们要让内核测试读丶写和异常条件的描述字。如果对某个的条件不感兴趣，就可以把它设置成空指针。struct 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 ）://检查集合中指定的文件描述符是否可以读写
	（3）timeout告知内核等待所指定描述字中一个就绪可花多长时间。其timeval结构用于指定这段时间的秒数和微秒数。
	struct timeval{
		long tv_sec;//秒
		long tv_usec;//微秒
}；

这个参数有三种可能：
（1）永远等待下去：仅在有一个描述字准备好I/O时才返回。为此，把该参数设置为空指针NULL。
（2）等待一段时间：在有一个描述字准备好I/O时返回，但是不超过由该参数指向的timeval结构中的秒数和微秒数。
（3）根本不等待：检查描述字后立即返回，这称为轮询。为此，该参数必须指向一个timeval结构，而且其中的定时器必须为0。
原理图如下：
下面是用select函数实现服务器端的代码：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include <time.h>
#include <pthread.h>
#include <getopt.h>
#include <libgen.h>
#include <sys/types.h> 
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
static inline void msleep(unsigned long ms);
static inline void print_usage(char *progname);
int socket_server_init(char *listen_ip, int listen_port);
int main(int argc, char **argv)
{
 	int listenfd, connfd; int serv_port = 0;
 	int daemon_run = 0;
 	char *progname = NULL;
 	int opt;
 	fd_set rdset;
 	int rv;
	int i, j;
 	int found;
	int maxfd=0;
	char buf[1024];
	int fds_array[1024];
 struct option long_options[] =
 { 
	 {"daemon", no_argument, NULL, 'b'},
	 {"port", required_argument, NULL, 'p'},
	 {"help", no_argument, NULL, 'h'},
	 {NULL, 0, NULL, 0}
 }; 
 progname = basename(argv[0]);
 /* Parser the command line parameters */
 while ((opt = getopt_long(argc, argv, "bp:h", long_options, NULL)) != -1)
 { 
	 switch (opt)
	 { 
		case 'b':
		daemon_run=1;
		break;
	 
 		case 'p':
 		serv_port = atoi(optarg);
 		break;
 	
 		case 'h': /* Get help information */
 		print_usage(progname);
 		return EXIT_SUCCESS;
 		default:
 		break;
	 } 
 } 
 if( !serv_port )
 { 
	 print_usage(progname);
	 return -1;
 }
 if( (listenfd=socket_server_init(NULL, serv_port)) < 0 )
 {
	 printf("ERROR: %s server listen on port %d failure\n", argv[0],serv_port);
	 return -2;
 }
 printf("%s server start to listen on port %d\n", argv[0],serv_port);
 /* set program running on background */
 if( daemon_run )
 {
	 daemon(0, 0);
 }
 for(i=0; i<ARRAY_SIZE(fds_array) ; i++)
 {
	 fds_array[i]=-1;
 }
 fds_array[0] = listenfd;
 for ( ; ; )
 {
	 FD_ZERO(&rdset);
	 for(i=0; i<ARRAY_SIZE(fds_array) ; i++)
 {
		 if( fds_array[i] < 0 )
 			continue;
		 maxfd = fds_array[i]>maxfd ? fds_array[i] : maxfd;
		 FD_SET(fds_array[i], &rdset);
 }
 /* program will blocked here */
	 rv = select(maxfd+1, &rdset, NULL, NULL, NULL);
	 if(rv < 0)
	 {
		 printf("select failure: %s\n", strerror(errno));
		 break;
	 }
	 else if(rv == 0)
	 {
		 printf("select get timeout\n");
		 continue;
	 }
 /* listen socket get event means new client start connect now */
	 if ( FD_ISSET(listenfd, &rdset) )
	 {
		 if( (connfd=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_array) ; i++)
		 {
			 if( fds_array[i] < 0 )
			 {
 					printf("accept new client[%d] and add it into array\n", connfd );
					 fds_array[i] = connfd;
					 found = 1;
					 break;
			 }
		 }
		 if( !found )
		 {
			 printf("accept new client[%d] but full, so refuse it\n", connfd);
			 close(connfd);
		 }
	 }
 else /* data arrive from already connected client */
 {
	 for(i=0; i<ARRAY_SIZE(fds_array); i++)
	 {
		 if( fds_array[i]<0 || !FD_ISSET(fds_array[i], &rdset) )
 		continue;
		 if( (rv=read(fds_array[i], buf, sizeof(buf))) <= 0)
		 {
			 printf("socket[%d] read failure or get disconncet.\n", fds_array[i]);
			 close(fds_array[i]);
			 fds_array[i] = -1;
		 }
		 else
		 {
			 printf("socket[%d] read get %d bytes data\n", fds_array[i], rv);
			 /* convert letter from lowercase to uppercase */
			 for(j=0; j<rv; j++)
			 buf[j]=toupper(buf[j]);
			 if( write(fds_array[i], buf, rv) < 0 )
			 {
				printf("socket[%d] write failure: %s\n", fds_array[i], strerror(errno));
				close(fds_array[i]);
				 fds_array[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);
}
static inline void print_usage(char *progname)
{
	 printf("Usage: %s [OPTION]...\n", progname);
 
	 printf(" %s is a socket server program, which used to verify client and echo back string from it\n",
progname);
	 printf("\nMandatory arguments to long options are mandatory for short options too:\n");
	 
	 printf(" -b[daemon ] set program running on background\n");
	 printf(" -p[port ] Socket server port address\n");
	 printf(" -h[help ] Display this help information\n");
 
	 printf("\nExample: %s -b -p 8900\n", progname);
	 return ;
}
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;
	 }
 /* Set socket port reuseable, fix 'Address already in use' bug when socket server restart */
	 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 ) /* Listen all the local IP address */
	 {
		 servaddr.sin_addr.s_addr = htonl(INADDR_ANY); 
	 }
	 else /* listen the specified IP address */
	 {
	 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("Use bind() to bind the TCP socket failure: %s\n", strerror(errno));
	 rv = -3;
	 goto CleanUp;
}
 if(listen(listenfd, 13) < 0)
	 {
		 printf("Use bind() to bind the TCP socket failure: %s\n", strerror(errno));
		 rv = -4;
		 goto CleanUp;
	 }
CleanUp:
	 if(rv<0)
	 close(listenfd);
 else
	 rv = listenfd;
	 return rv;
}

select的缺点：
1.可监控的文件描述符集大小有限制，sizeof(fd_set)根据机器不同，这边的数值为128字节，说明可监控文件描述符为1024个 。
2. 每次调用select,都需要自己手动设置fd_set，从接口使用来说不方便，并且输入输出参数为一个值，还需要自己维护第三个变量。
3. 每次调用select 都需要将fd集从用户态拷贝到内核态，这边为128*3字节，虽然感觉上不大，但是拷贝次数太频繁。
4.每次不管是内核还是我们自己在使用的时候，都要遍历fd，开销也挺大的。