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

谁借莪１个温暖的怀抱￠ 2022-06-12 01:12 140阅读 0赞

系统提供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