【Linux】中I/O多路转接之select

系统提供select函数来实现多路复用输入/输出模型。select系统调用是用来让我们的程序监视多个事件句柄的状态变化的。 程序会停在select这里等待，直到被监视的事件句柄有一个或多个发生了状态改变。 关于事件句柄，其实就是一个整数，我们最熟悉的句柄是0、1、2三个，0是标准输入，1是标准输出，2是标准错误输出。0、1、2是整数表示的，对应的FILE *结构的表示就是stdin、stdout、stderr。

常见的程序段如下：
fs_set readset；
FD_SET(fd,&readset);
select(fd+1,&readset,NULL,NULL,NULL);
if(FD_ISSET(fd,readset)){……}

对select的理解：

理解select模型的关键在于理解fd_set,为说明方便，取fd_set长度为1字节，fd_set中的每一bit
可以对应一个事件描述符fd。则1字节长的fd_set最⼤可以对应8个fd。
（1）执行fd_set set; FD_ZERO(&set);则set用位表示是0000,0000。
（2）若fd＝5,执行FD_SET(fd,&set);后set变为0001,0000(第5位置为1)
（3）若再加入fd＝2，fd=1,则set变为0001,0011
（4）执行select(6,&set,0,0,0)阻塞等待
（5）若fd=1,fd=2上都发生可读事件，则select返回，此时set变为0000,0011。注意：没有事件
发生的fd=5被清空

dup/dup2：对输入文件描述符重定向。

代码的编写：

dup.c

#include<stdio.h>
#include<unistd.h>
#include<fcntl.h>
#include<string.h>

int main()
{
	int fd=open("./log",O_CREAT | O_RDWR);
	if(fd<0)
	{
		perror("open()");
		return fd;
	}
	close(1);
	int new_fd = dup(fd);
	if(new_fd == 1)
	{
		perror("dup()");
		return -1;
	}
	close(fd);
	char buf[1024];
	while(1)
	{
		memset(buf,'\0',sizeof(buf));
		fgets(buf,sizeof(buf),stdin);
		if(strncmp("quit",buf,4) == 0)
		{
			break;
		}
		printf("%s",buf);
		fflush(stdout);
	}
	close(new_fd);
}

dup2.c

#include<stdio.h>
#include<unistd.h>
#include<fcntl.h>
#include<string.h>
int main()
{
	int fd=open("./log",O_CREAT | O_RDWR);
	if(fd<0)
	{
		perror("open()");
		return -1;
	}
	close(1);
	int ret =dup2(fd,1);
	char buf[1024];
	while(1)
	{
		memset(buf,'\0',sizeof(buf));
		fgets(buf,sizeof(buf),stdin);
		if(strncmp("quit",buf,4) == 0)
		{
			break;
		}
		printf("%s",buf);
		fflush(stdout);
	}
	close(fd);
}

select服务器：

先是select.c

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

static void usage(const char* proc)//打印字符串的函数
{
	printf("Usagr:%s[local_ip][local_proc]\n",proc);
}

int readfds[sizeof(fd_set)*8];//定义文件描述符数组，存储要等待的文件描述符
int startup(char *ip,int port)//监听服务器
{
	int sock = socket(AF_INET,SOCK_STREAM,0);
	if(sock<0)//如果sock的值小于0
	{
		perror("socket");//打印错去码
		exit(0);//直接退出
	}
	struct sockaddr_in local;
	local.sin_family = AF_INET;
	local.sin_port = htons(port);
	local.sin_addr.s_addr = inet_addr(ip);

	if(bind(sock,(struct sockaddr*)&local,sizeof(local))<0)
	{
		perror("bind");
		exit(2);
	}
	if(listen(sock,5)<0)
	{
		perror("listen");
		exit(3);
	}
	return sock;
}
int main(int argc,char* argv[])
{
	if(argc != 3)
	{
		usage(argv[0]);
		return 4;
	}
	int listen_sock = startup(argv[1],atoi(argv[2]));
	int i=1;
	int num =sizeof(fd_set)*8;
	readfds[0] = listen_sock;
	for(;i<num;++i)
	{
		readfds[i] = -1;
	}
	fd_set wfds,rfds;
	char buf[1024];
	while(1)
	{
		int maxfd = -1;
		FD_ZERO(&rfds);
		for(i=0;i<num;++i)
		{
			if(readfds[i]!=-1)
			{
				FD_SET(readfds[i],&rfds);
			}
			maxfd = maxfd<readfds[i]?readfds[i]:maxfd;
		}
		struct timeval time = {1,0};
		int n = select(maxfd+1,&rfds,&wfds,NULL,&time);
		switch(n)
		{
			case 0:

				printf("time out...\n");
				break;
			case -1:
				break;
			default:
				{
					i = 0;
					for(;i<num;++i)
					{
						if(i==0 && FD_ISSET(readfds[i],&rfds))
						{
							struct sockaddr_in client;
							socklen_t len =sizeof(client);
							int client_sock = accept(listen_sock,(struct sockaddr*)&client,&len);

							if(client_sock<0)
							{
								perror("accept");
								continue;
							}
							else

							{
								int j=0;
								for(j=1;j<num;++j)
								{
									if(readfds[j] == -1)

									{
										readfds[j] = client_sock;
										break;
									}

								}
								if(j>=num)

								{
									printf("readfds is full\n]");
									return 5;
								}
							}
						}

						if(i != 0 &&FD_ISSET(readfds[i],&rfds))
						{
							int s=read(readfds[i],buf,sizeof(buf)-1);
							if(s<0)
							{

								perror("read");
								return 6;
							}
							else if(s == 0)

							{
								printf("client qiut\n");
								readfds[i] = -1;
								close(readfds[i]);
								continue;

							}
							else
							{
								buf[s]=0;
								printf("client#: %s\n",buf);
								fflush(stdout);
								write(readfds[i],buf,strlen(buf));

							}
						}
					}
					break;
				}
		}
	}
	return 0;
}

然后是client.c

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<string.h>
#include<netinet/in.h>
#include<unistd.h>

static void  usage()
{
	printf("........:[ipaddr],[port]\n");
	exit(1);
}

int main(int argc,char* argv[])
{
	if(argc!=3)
	{
		usage();
	}
	int sockfd=socket(AF_INET,SOCK_STREAM,0);
	if(socket<0)
	{
		perror("socket");
		return 2;
	}
	struct sockaddr_in addr;
	addr.sin_family = AF_INET;
	addr.sin_port=htons(atoi(argv[2]));
	addr.sin_addr.s_addr = inet_addr(argv[1]);

	if(connect(sockfd,(struct sockaddr*)&addr,sizeof(addr))<0)
	{
		perror("connect");
		return 3;
	}
	else
	{
		printf("connect success\n");
		char buf[1024];
		while(1)
		{
			printf("client :");
			fflush(stdout);
			ssize_t s = read(0,buf,sizeof(buf)-1);
			if(s<0)
			{
				perror("read");
				return 4;
			}
			else
			{
				buf[s]='\0';
				int fd = dup(1);
				dup2(sockfd,1);
				printf("%s",buf);
				fflush(stdout);
				dup2(fd,1);
			}
			s = read(sockfd,buf,sizeof(buf)-1);
			if(s==0)
			{
				printf("server quit\n");
				break;
			}
			else if(s<0)
			{
				perror("read");
				return 5;
			}
			else
			{
				buf[s-1]='\0';
				printf("server:%s\n",buf);
			}
		}
		close(sockfd);
	}
	return 0;
}

select的优点和缺点：

优点：
（1）不需要建立多个线程、进程就可以实现一对多的通信。
（2）可以同时等待多个文件描述符，效率比起多进程多线程来说要高很多；
缺点：
（1）每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多时会很大
（2）同时每次调用select都需要在内核遍历传递进来的所有fd，这个开销在fd很多时也很大
（3）select支持的文件描述符数量太大了，默认是1024