Linux网络编程【五】：TCP协议高性能服务器(http)模型之I/O多路转接select

「爱情、让人受尽委屈。」 2022-06-14 00:41 125阅读 0赞

dup:

![SouthEast][]

![SouthEast 1][]

dup用来复制oldfd所指的文件描述符。但复制成功时返回最小的尚未被使用的文件描述符。若有错误则返回－1，错误代码存入errno中。返回的新文件描述符和参数oldfd指向同一个文件，共享所有的锁定，读写指针，和各项权限或标志位。  
1.打开一个新文件  
2.关掉标准输出文件符  
3.调用dup给文件描述符  
4.此时文件描述符变为1  
5.将所要打印数据重定向到文件中

I/O多路转接之select

系统提供select函数来实现多路复用输入/输出模型。select系统调用是用来让我们的程序监视多个文件句柄的状态变化的。  
select:该函数允许进程指示内核等待多个事件中的任何一个发生，并只在有一个或多个事件发生或经历一段指定的时间后才唤醒它。

![SouthEast 2][]

参数意义：

nfds:待测试描述符个数。最大文件描述符+1

readfds/writefds/exceptfds：分别对应于需要检测的可读文件件描述符的集合，可写文件描述符的集 合及异常文件描述符的集合。

异常原因：  
1.某个套接字的带外数据的到达  
2.某个已置为分组模式的伪终端存在可从其主端读取的控制状态信息  
select使用描述符集，通常是一个整形数组，其中每个整数中每一位对应一个描述符

其中四个宏：

下面的宏提供了处理这三种描述词组的方式:  
FD\_CLR(inr fd,fd\_set\* set)；用来清除描述词组set中相关fd 的位  
FD\_ISSET(int fd,fd\_set \*set)；用来测试描述词组set中相关fd 的位是否为真  
FD\_SET（int fd,fd\_set\*set）；用来设置描述词组set中相关fd的位  
FD\_ZERO（fd\_set \*set）；用来清除描述词组set的全部位

timeout:它告知内核等待所制定描述符中的任何一个就绪可在多长时间，其timeval结构用于指定这段时间的秒数和微妙数。  
struct timeval  
\{  
long tv\_sec;//seconds  
long tv\_usec;//microseconds  
\}  
有三种情况：  
永远等待下去：仅在有一个描述符准备好I/O时才返回，为此，我们把该参数设为NULL.  
等待固定时间：在有一个描述符准备好I/O时返回，但是不超过由该参数所指向的timeval结构中指定的秒数和微妙数。  
根本不等待：检查描述符后立即返回，这称为轮询，为此该参数必须指向一个timeval结构，而且其中的定时器值必须为0；  
前两种情形的等待通常会被进程在等待期间捕获的信号中断，并从信号处理函数返回。  
注：有的Linux会在select函数返回时修改timeval结构，从移植性考虑，我们应假设timeval结构在函数返回时未定义，因而每次调用select前都得对它进行初始化。

函数返回值：  
执行成功则返回文件描述词状态已改变的个数  
如果返回0代表在描述词状态改变前已超过timeout时间，没有返回；  
当有错误发生时则返回-1， 错误原因存于errno，此时参数readfds，writefds，exceptfds和timeout的值变成不可预测。错误值可能为：  
EBADF 文件描述词为无效的或该文件已关闭  
EINTR 此调用被信号所中断  
EINVAL 参数n 为负值。  
ENOMEM 核心内存不足

select和多进程/多线程优缺点比较：

多进程/线程方法的优点：  
每个独立进程处理一个独立的client，对server进程来说只需要accept新的连接，对每个子进程来说只需要处理自己的client即可。  
多进程、线程方法的缺点：  
子进程的创建需要独立的父进程资源副本，开销较大，对高并发的请求不太适合；且一个进程仅处理一个client不能有效发挥作用。另外有些情况下还需要进程间进行通信以协调各进程要完成的任务。

select

优点：相比起多进程/线程 缩短了等待时间，提高效率，减少进程占用内存开销

缺点：

（1）每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多时会很大  
（2）同时每次调用select都需要在内核遍历传递进来的所有fd，这个开销在fd很多时也很大  
（3）select支持的文件件描述符数量太小了，默认是1024  
  
使用select实现服务器代码：

#include<stdio.h>
    #include<sys/types.h>
    #include<netinet/in.h>
    #include<arpa/inet.h>
    #include<sys/socket.h>
    #include<stdlib.h>
    #include<string.h>
    
    int array_fds[1024];
    
    static void Usage(char* proc)
    {
    	printf("Usage: %s [local_ip] [local_port]", proc);
    }
    
    int startup(char* _ip, int _port)
    {
    	int sock = socket(AF_INET, SOCK_STREAM, 0);
    	if(sock < 0)
    	{
    		perror("socket");
    		return 2;
    	}
    
    	int flg = 1;
    	setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &flg, sizeof(flg));
    
    	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");
    		return 3;
    	}
    
    	if(listen(sock, 5) < 0)
    	{
    		perror("listen");
    		return 0;
    	}
    	return sock;
    }
    
    int main(int argc, char* argv[])
    {
    	if(argc != 3)
    	{
    		Usage(argv[0]);
    		return 1;
    	}
    
    	int listen_socket = startup(argv[1], atoi(argv[2]));
    
    	fd_set rfds;
    	int max_fd = 0;
    	int array_size = sizeof(array_fds)/sizeof(array_fds[0]);
    	array_fds[0] = listen_socket;
    	int i = 0;
    	for(i = 1; i < array_size; i++)
    	{
    		array_fds[i] = -1;
    	}
    	while(1)
    	{
    		max_fd = -1;
    		struct timeval timeout = {0,0};
    		FD_ZERO(&rfds);
    		for(i = 0; i < array_size; i++)
    		{
    			if(array_fds[i] > 0)
    			{
    				FD_SET(array_fds[i], &rfds);
    				if(array_fds[i] > max_fd)
    				{
    					max_fd = array_fds[i];
    					//printf("i:%d,  %d\n",i,max_fd);
      				}
    			}
    		}
    
    		switch(select(max_fd+1, &rfds, NULL,/*&rfds,*/ NULL, NULL))
    		{
    			case 0:
      				printf("timeout...\n");
    				break; 
    			case -1:
     				perror("select");
     				break; 
    			default:
     				{ 
    					//printf("select sus\n");
     					int k = 0;
    					for(;k < array_size; k++)
    					{
    				  		if(array_fds[k] < 0)
    							continue;
    
    					   //	printf("k = %d, array_fds[k] : %d\n",k,array_fds[k]);
    						if(k == 0 && FD_ISSET(array_fds[k], &rfds))
    						{
    					 	//	printf(" Accept\n");
    				 			struct sockaddr_in client;
    							socklen_t len = sizeof(client);
    						    int new_sock = accept(array_fds[k], (struct sockaddr*)&client, &len);
    							if(new_sock < 0)
    							{
     								perror("accept");
    								continue; 
    							}
    							else
    							{
    								printf("get a client : %s ,  %d \n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));
    								int j = 1;
    								for(;j < array_size;j++)
    								{
     					 				if(array_fds[j] < 0)  
    									{
    					 					array_fds[j] = new_sock;
     										break;
    									}
    								}
    								if(j == array_size)
     				 					close(new_sock);
    							//	printf("j:%d\n",j);
    							//	printf("array_fds[1]:%d\n",array_fds[j]);
     			 	  			}
     			 			}
    						else if(k != 0 && FD_ISSET(array_fds[k],&rfds))
    						{
    						//	printf("input\n");
    					  	    char buf[10240];
    					  	 	ssize_t s = read(array_fds[k], buf, sizeof(buf)-1);
    					  	 	if(s > 0)
    					  	 	{
    	 				  	 		buf[s] = 0; 
     			 		  	 	 	printf("client say# %s \n", buf);
    								write(array_fds[k], buf, strlen(buf));
    					  	 	}
    					  	 	else if(s == 0)
    					  	 	{
    	 				  	 	 	printf("client quit ...\n");
    					  	 		close(array_fds[k]);
     					  	 		array_fds[k] = -1;
    					  	 	}
    					  	 	else
    					  	 	{
    								perror("read");
    	 				  	 		close(array_fds[k]);
     			 		  	 	 	array_fds[k] = -1;
     					   	 	}  
    					 	}
    						else
    						{
        					}
    					 } 
    					
    				}
    				break; 
    		}
    	}
    	return 0;
    }

客户端代码：

#include<stdio.h>
    #include<sys/types.h>
    #include<netinet/in.h>
    #include<arpa/inet.h>
    #include<sys/socket.h>
    #include<stdlib.h>
    #include<string.h>
    #include<strings.h>
    #include<sys/stat.h>
    #include<unistd.h>
    static void Usage(char * proc)
    {
    	printf("Usage : %s [ip] [port]\n");
    }
    
    int main(int argc, char* argv[])
    {
    	if(argc != 3)
    	{
    		Usage(argv[0]);
    		return 1;
    	}
    
    	int sock = socket(AF_INET, SOCK_STREAM, 0);
    	struct sockaddr_in peer;
    	peer.sin_family = AF_INET;
    	peer.sin_port = htons(atoi(argv[2]));
    	peer.sin_addr.s_addr = inet_addr(argv[1]);
    
    	if(connect(sock, (struct sockaddr*)&peer, sizeof(peer)) < 0)
    	{
    		perror("connect");
    		return 2;
    	}
    
    	char buf[10240];
    	//int sfd = dup(STDOUT_FILENO);
    	while(1)
    	{
    		printf("Please Enter : ");
    		fflush(stdout);
    		ssize_t s = read(0, buf, sizeof(buf)-1);
            int sfd = dup(STDOUT_FILENO);
    		if(s > 0)
    		{
    			buf[s-1] = 0;
    			//write(sock, buf, strlen(buf));
    			//输出重定向
                //close(1);
    		   // int new_fd = dup(sock);
    		   int new_fd = dup2(sock, 1);
                if(new_fd == -1)
    		    {
    		 	   perror("dup()");
    		 	   return -1;
    		    }
                printf("%s",buf);
    		    fflush(stdout);
    			//恢复stdout
    			dup2(sfd, STDOUT_FILENO);
    			
    	        ssize_t _s = read(sock, buf, sizeof(buf)-1);
    		    if(_s > 0)
    		    {
    			   buf[_s] = 0;
    			   printf("sever # %s \n", buf);
    		    }
    		}
    	}
    	close(sock);
    	return 0;
    }

![SouthEast 3][]

![SouthEast 4][]

![SouthEast 5][]

[SouthEast]: /images/20220614/71c0bf43b7f5473ca623a7c16d929078.png
[SouthEast 1]: /images/20220614/a4a6caeadd284e5eb3c4f731ae93c7e2.png
[SouthEast 2]: /images/20220614/d6471d1886004d399533b8818d075966.png
[SouthEast 3]: /images/20220614/4345493fd0e3469680675d07669392a1.png
[SouthEast 4]: /images/20220614/81e13c352f56406b8fbd9486686d5fac.png
[SouthEast 5]: /images/20220614/ac9c5127c4d045b899cd1bcdb282dbd8.png