I/O多路复用—select服务器

1、基本概念

　　IO多路复用是指内核一旦发现进程指定的一个或者多个IO条件准备读取，它就通知该进程。IO多路复用适用如下场合：

　　（1）当客户处理多个描述字时（一般是交互式输入和网络套接口），必须使用I/O复用。

　　（2）当一个客户同时处理多个套接口时，而这种情况是可能的，但很少出现。

　　（3）如果一个TCP服务器既要处理监听套接口，又要处理已连接套接口，一般也要用到I/O复用。

　　（4）如果一个服务器即要处理TCP，又要处理UDP，一般要使用I/O复用。

　　（5）如果一个服务器要处理多个服务或多个协议，一般要使用I/O复用。

　　与多进程和多线程技术相比，I/O多路复用技术的最大优势是系统开销小，系统不必创建进程/线程，也不必维护这些进程/线程，从而大大减小了系统的开销。

2、select函数

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

函数原型：

int select(int nfds, fd_set* readfds, fd_set* writefds, 
            fd_set* xceptfds, struct timeval* timeout);

 
 
1
2
3
 
 
1
2
3

参数解释： 
struct fd_set结构体： 
可以理解为一个集合，并且以位图形式表示，这个集合中存放的是文件描述符（文件句柄），这可以是我们所说的普通意义的文件。UNIX下一切皆文件，所以socket就是一个文件，socket句柄就是一个文件描述符。与fd_set相关的宏：

void FD_CLR(int fd, fd_set* set);//清除描述次组set中关于fd的位（从集
//合中删除一个给定的文件描述符）

int FD_ISSET(int fd, fd_set* set);//测试描述次组set中相关fd的位是否
//为真（检查集合中指定的文件描述符是否可以读写）

void FD_SET(int fd, fd_set* set);//设置描述次组set中相关fd的位，即将
//一个给定的文件描述符假如集合中

void FD_ZERO(int fd, fd_set* set);//清除集合
 
 
1
2
3
4
5
6
7
8
9
10
 
 
1
2
3
4
5
6
7
8
9
10

timeval结构体：

struct timeval:
{
     long tv_sec;/*second*/
     long tv_usec;/*microsecond*/
}
 
 
1
2
3
4
5
 
 
1
2
3
4
5

timeval结构体用来设置select()的等待时间，如果在这段时间内监听的文件描述符没有事件发生则返回0。该结构体有以下三种可能： 
（1）永远等待下去：仅在有一个文件描述符准备好I/O后才返回，因此可以将timeout设置为空指针 
（2）等待一段固定时间：在有一个文件描述符准备好I/O时返回，但是不超过由该参数所指向的timeval结构体中指定的秒数和毫秒数 
（3）不等待：检查文件描述符后立即返回，称为轮询（polling）。因此，该参数指向的timeval结构体中的定时器的值必为0。 
在前两种情况下，如果进程捕获了一个信号并从信号处理程序返回，那么等待一般会被中断。

• timeout 的设置：

NULL：表示select()没有timeout，select将一直被阻塞，直到某个文件描述符上发生了时间； 
0：仅检测文件描述符集的状态，然后立即返回，并不等待外部事件的发生； 
特定的时间值：如果在指定时间内没有事件发生，则select超时返回。

• nfds：

需要监视的最大文件描述符值+1，上边说过fd_set中存放的是文件描述符，它其实是告诉操作系统去监控的文件描述符的集合大小，但它是从0开始表示的，因此这里的文件描述符的个数就为最大值+1。

• 三个流集合：

fd_set* readfds：读流集合，希望从这些描述符中读内容 
fd_set* writefds：写流集合，希望向这些描述符中写内容 
fd_set* exceptfds：异常流集合，中间过程发送了异常。 
这三个参数指定我们要让内核测试读、写、异常条件的文件描述符。如果对某一个的条件不感兴趣，就把它设置为空指针。

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

基本原理：

测试代码：

客户端代码：

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

int main()
{
	int fd=open("./file",O_CREAT | O_RDWR,0666);
	if(fd<0){
		perror("open");
		return 0;
	}

	close(1);
	int new_fd=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(new_fd);
}

服务器端代码：

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

int array_fds[1024];

static void Usage(const char *proc)
{
	printf("Usage: %s [local_ip] [local_port]\n",proc);
}

int startup(char *_ip,short _port)
{
	int sock=socket(AF_INET,SOCK_STREAM,0);
	if(sock<0){
		perror("socket");
		exit(2);
	}

	int flag=1;
	setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&flag,sizeof(flag));

	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(3);
	}

	if(listen(sock,10)<0){
		perror("listen");
		exit(4);
	}
	return sock;
}


int main(int argc,char *argv[])
{
	if(argc!=3){
		Usage(argv[0]);
		return 0;
	}
	int listenSock=startup(argv[1],atoi(argv[2]));
	int maxfd=0;
	fd_set rfds;
	int array_size=sizeof(array_fds)/sizeof(array_fds[0]);
	array_fds[0]=listenSock;
	
	int i=1;
	for(;i<array_size;i++){
		array_fds[i]=-1;
	}
	while(1){
		struct timeval _timeout={0,0};
		FD_ZERO(&rfds);
		maxfd=-1;
		
		for(i=0;i<array_size;++i){
			if(array_fds[i]>0){
				FD_SET(array_fds[i],&rfds);
				if(array_fds[i]>maxfd)
					maxfd=array_fds[i];
			}
		}
		
		switch(select(maxfd+1,&rfds,NULL,NULL,NULL)){
			case 0:
				printf("timeout...\n");
				break;
			case -1:
				perror("select");
				break;
			default:
				{
				int j=0;
				for(;j<array_size;j++){
					if(array_fds[j]<0)
						continue;
					if(j==0&&FD_ISSET(array_fds[j],&rfds)){
						struct sockaddr_in client;
						socklen_t len=sizeof(client);
						int new_fd=accept(array_fds[j],\
								(struct sockaddr*)&client,&len);
						if(new_fd<0){
							perror("accept");
							continue;
						}else{
							printf("get a new client:(%s:%d)\n",\
									inet_ntoa(client.sin_addr),\
									ntohs(client.sin_port));
							int k=1;
							for(;k<array_size;++k){
								if(array_fds[k] < 0 )
								{
									array_fds[k] = new_fd;
									break;
								}
							}
							if(k==array_size){
								close(new_fd);
							}
						}
					}//fi
					else if(j!=0&&FD_ISSET(array_fds[j],&rfds)){
						char buf[10240];
						size_t s=read(array_fds[j],buf,sizeof(buf)-1);
						if(s>0){
							buf[s]=0;
							printf("client say :%s\n",buf);
						}else if(s==0){
							printf("client quit!\n");
							close(array_fds[j]);
							array_fds[j]=-1;
						}else{
							perror("read");
							close(array_fds[j]);
							array_fds[j]=-1;
						}
					}
					else{}
				}
			}
			break;	
		}
	}	
	return 0;
}

测试结果：

客户端

服务端