I/O复用select减少查找通信socket循环次数的优化

存在的问题

如果需要内核监控的可读文件描述符集中，存在大量的已关闭的空余位置，但是查找通信socket的时候仍然需要遍历，那么会有多余的循环次数，且每轮都会重复无用功

未改进之前的代码框架，每次客户端请求到来后，都要将产生的通信socket加入到监测内容中，同时需要监测的范围maxfd也随之变大，但是在遍历通信socket的过程中，可能有的通信socket已经出错或者客户端连接断开了，这些位置的文件描述符必然不会发生就绪事件，也就是不会存在在select传出的就绪文件描述符集中，轮询的过程中，一直遍历到最大的maxfd的位置，造成了循环的多余。

fs_set readfds//定义文件描述符集变量
fd_set tmpfds;
FD_ZERO(&readfds);//清空文件描述符集变量
FD_SET(lfd,&readfds);//将监听文件描述符加入到readfds集合中
maxfd=lfd+1;//最大监控范围
while(1){//内核持续监控
    tmpfds=readfds;
    nready=select(maxfd,&temfds,NULL,NULL,NULL);
    if(nready<0){
        if(errno==EINTR){//信号可以将阻塞函数中断，这不是错误
            continue;
        }
        break;//真正的错误
    }
    //有客户端连接请求到来
    if(FD_ISSET(lfd,&tmpfds)){
        //接收新的客户端连接请求
        cf=accept(lfd,NULL,NULL);
        //将cfd加入readfds集合
        FD_SET(cfd,&readfds);
        //修改内核监控的文件描述符的范围
        if(maxfd<cfd){
            maxfd=cfd+1;
        }
        if(--nready==0){//此时只有一个客户端连接请求，处理完后直接返回
            continue;
        }
    }
    //有客户端数据发来
    for(i=lfd+1;i<maxfd+1;i++){//有可能多个客户端发送数据
        if(FD_ISSET(i,&tmpfds)){
            while(1){
                //read数据，不会阻塞，因为内核已经告诉你有数据
                n=read(i,buf,sizeof(buf));
                if(n<0){//读异常，或客户端关闭连接
                close(i);
                //将文件描述符i从内核去除
                FD_CLR(i,&readfds);
                }
        	    //write应答数据给客户端
     	        write(i,buf,n);
            }
        }
    }
    close(lfd);
    return 0;
}

代码优化方向

1. 将通信文件描述符保存到一个整型数组中，使用一个变量记录数组中最大元素的下标
2. 如果数组中有无效的文件描述符，直接跳过

每接收到一个客户端的连接，就把通信文件描述符加到监测文件描述符集中，同时也加入到有效文件描述符数组中，加入的数组元素的位置是最小的未被占用的位置，若maxi之前存在空余位置则占用，若不存在则将maxi向后移动。
那么遍历可读的通信socket的时候，就可以只遍历有效文件描述符次，即将数组中的文件描述符与读就绪文件描述符集中的进行比对即可，而之前需要将从lfd到最大maxfd的所有位置的文件描述符与读就绪进行比较(即使中间的文件描述符已经无效或关闭，也要对比)。

//IO多路复用技术select函数的使用 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/select.h>

int main()
{
	int i;
	int n;
	int lfd;
	int cfd;
	int ret;
	int nready;
	int maxfd;//最大的文件描述符
	char buf[FD_SETSIZE];
	socklen_t len;
	int maxi;  //有效的文件描述符最大值
	int connfd[FD_SETSIZE]; //有效的文件描述符数组
	fd_set tmpfds, rdfds; //要监控的文件描述符集
	struct sockaddr_in svraddr, cliaddr;

	//创建socket
	lfd = socket(AF_INET, SOCK_STREAM, 0);
	if(lfd<0)
	{
		perror("socket error");
		return -1;
	}

	//允许端口复用
	int opt = 1;
	setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int));

	//绑定bind
	svraddr.sin_family = AF_INET;
	svraddr.sin_addr.s_addr = htonl(INADDR_ANY);
	svraddr.sin_port = htons(8888);
	ret = bind(lfd, (struct sockaddr *)&svraddr, sizeof(struct sockaddr_in));
	if(ret<0)
	{
		perror("bind error");
		return -1;
	}

	//监听listen
	ret = listen(lfd, 5);
	if(ret<0)
	{
		perror("listen error");
		return -1;
	}

	//文件描述符集初始化
	FD_ZERO(&tmpfds);
	FD_ZERO(&rdfds);

	//将lfd加入到监控的读集合中，委托内核监控
	FD_SET(lfd, &rdfds);

	//初始化有效的文件描述符集, 为-1表示可用, 该数组不保存lfd
	for(i=0; i<FD_SETSIZE; i++)
	{
		connfd[i] = -1;
	}

	maxfd = lfd;
	len = sizeof(struct sockaddr_in);

	//将监听文件描述符lfd加入到select监控中
	while(1)
	{
		//select为阻塞函数,若没有变化的文件描述符,就一直阻塞,若有事件发生则解除阻塞,函数返回
		//select的第二个参数tmpfds为输入输出参数,调用select完毕后这个集合中保留的是发生变化的文件描述符
		tmpfds = rdfds;
		nready = select(maxfd+1, &tmpfds, NULL, NULL, NULL);
		if(nready<0){
			if(errno==EINTR){//被信号中断
				continue;
			}
			break;
		}
		if(nready>0)
		{
			//发生变化的文件描述符有两类, 一类是监听的, 一类是用于数据通信的
			//监听文件描述符有变化, 有新的连接到来, 则accept新的连接
			if(FD_ISSET(lfd, &tmpfds))	
			{
				cfd = accept(lfd, (struct sockaddr *)&cliaddr, &len);			
				if(cfd<0)
				{
					if(errno==ECONNABORTED || errno==EINTR)
					{
						continue;
					}
					break;
				}

				//先找位置, 然后将新的连接的文件描述符保存到connfd数组中
				for(i=0; i<FD_SETSIZE; i++)
				{
					if(connfd[i]==-1)
					{
						connfd[i] = cfd;
						break;
					}
				}
				//若连接总数达到了最大值,则关闭该连接
				if(i==FD_SETSIZE)
				{	
					close(cfd);
					printf("too many clients, i==[%d]\n", i);
					//exit(1);
					continue;
				}

				//确保connfd中maxi保存的是最后一个文件描述符的下标
				if(i>maxi)
				{
					maxi = i;
				}

				//打印客户端的IP和PORT
				char sIP[16];
				memset(sIP, 0x00, sizeof(sIP));
				printf("receive from client--->IP[%s],PORT:[%d]\n", inet_ntop(AF_INET, &cliaddr.sin_addr.s_addr, sIP, sizeof(sIP)), htons(cliaddr.sin_port));

				//将新的文件 描述符加入到select监控的文件描述符集合中
				FD_SET(cfd, &rdfds);
				if(maxfd<cfd)
				{
					maxfd = cfd;
				}

				//若没有变化的文件描述符,则无需执行后续代码
				if(--nready<=0)
				{
					continue;
				}	
			}

			//下面是通信的文件描述符有变化的情况
			//只需循环connfd数组中有效的文件描述符即可, 这样可以减少循环的次数
			for(i=0; i<=maxi; i++)
			{
				int sockfd = connfd[i];
				//数组内的文件描述符如果被释放有可能变成-1
				if(sockfd==-1)
				{
					continue;
				}

				if(FD_ISSET(sockfd, &tmpfds))
				{
					memset(buf, 0x00, sizeof(buf));
					n = read(sockfd, buf, sizeof(buf));
					if(n<0)
					{
						perror("read over");
						close(sockfd);
						FD_CLR(sockfd, &rdfds);
						connfd[i] = -1; //将connfd[i]置为-1,表示该位置可用
					}
					else if(n==0)
					{
						printf("client is closed\n");	
						close(sockfd);
						FD_CLR(sockfd, &rdfds);
						connfd[i] = -1; //将connfd[i]置为-1,表示该位置可用
					}
					else
					{
						printf("[%d]:[%s]\n", n, buf);
						write(sockfd, buf, n);
					}

					if(--nready<=0)//后面空的fd就不再检查是否变化
					{
						break;  //注意这里是break,而不是continue, 应该是从最外层的while继续循环
					}
				}	
			}
		}	
	}

	//关闭监听文件描述符
	close(lfd);

	return 0;
}