Linux网络编程--单进程服务器处理多客户请求（I/O复用）

采用I/O复用可以使用单进程的服务器去处理多个客户的连接请求，而不需要为每个客户分配单独的进程或线程去专门的处理客户请求；

I/O复用的模型：

进程阻塞于select()，而select检测相应的描述符集，如果有就绪的描述符，则退出阻塞，然后进程判断就绪的描述符并作相应的处理；

下面的例子根据前面的文章：http://blog.csdn.net/hjj414/article/details/21642183中的程序修改而来；

功能：

服务器仅仅读取客服发送的数据，并显示到屏幕上；

客户端仅仅发送数据到服务器；

服务器代码：

int main(int argc, char **argv)
{
	int listenfd;
	struct sockaddr_in servaddr;
	
	/*socket*/
	listenfd = socket(AF_INET, SOCK_STREAM, 0);
	if (-1 == listenfd) {
		perror("socket error.");
		return -1;
	}
	/*init IP address*/
	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(1234);
	/*set prot reuse*/
	const int onflg = 1;
	if (-1 == setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &onflg, sizeof(onflg))) {
		perror("set socket prot reuse error.");
		return -1;
	}
	/*bind*/
	if (-1 == bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr))) {
		perror("bind error.");
		return -1;
	}
	/*listen*/
	if (-1 == listen(listenfd, 10)) {
		perror("listen error.");
		return -1;
	}//调用listen后建立了一个监听socket，如果没有客户连接，此时监听socket的‘已完成连接队列’为空；
	 //accept函数将读取监听socket的已完成连接队列，如果队列为空accept将阻塞，直到队列不为空，即当
	 //监听socket可读的时候，accept才从退出阻塞状态；所以使用I/O复用模型，使用select函数来测试
	 //监听socket，当其可读时，调用accept；
	serv_io_multiplex(listenfd);
	
	return 0;
}

serv_io_multiplex:

struct cli_array_t {//记录已连接的soket描述符
	int clifd[FD_SETSIZE];	//已连接的socket
	struct sockaddr_in *cliad[FD_SETSIZE];//客户IP地址
	int maxi; //记录clifd数组中有记录的最大下标
	int maxfd; //最大的描述符
};
#define BSIZE 100
int serv_io_multiplex(int listenfd)
{
	int connfd;
	struct sockaddr_in cliaddr;
	socklen_t clilen;

	fd_set allset, rset; //allset为所有待检测的读描述符集，rset为当前检测的读描述符集
	int nready, i; //nready记录当前描述符集中有多少个准备就绪
	char buf[BSIZE];
	ssize_t n;
	struct cli_array_t cliarr;
	
	for (i = 0; i < FD_SETSIZE; i ++) {
		cliarr.clifd[i] = -1;
		cliarr.cliad[i] = NULL;
	}
	cliarr.maxi = -1;
	cliarr.maxfd = listenfd;

	FD_ZERO(&allset);
	FD_SET(listenfd, &allset); //将监听socket加入allset中

	while (1) {
		rset = allset; //更新当前检测的读描述符集
		nready = select(cliarr.maxfd+1, &rset, NULL, NULL, NULL);
		if (-1 == nready) {
			perror("select error.");
			return -1;
		}
		/*client connected*/
		if (FD_ISSET(listenfd, &rset)) {//监听socket准备就绪
			clilen = sizeof(cliaddr);
			connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &clilen);
			if (-1 == connfd) {
				perror("accept error.");
				return -1;
			}
			for (i = 0; i < FD_SETSIZE; i ++) { //记录已连接socket，并记录客户IP
				if (cliarr.clifd[i] < 0) {
					cliarr.clifd[i] = connfd;
					cliarr.cliad[i] = malloc(sizeof(cliaddr));
					if (NULL == cliarr.cliad[i]) {
						printf("malloc error.\n");
						return -1;
					}
					cliarr.cliad[i]->sin_addr = cliaddr.sin_addr;
					cliarr.cliad[i]->sin_port = cliaddr.sin_port;
					break;
				}
			}
			FD_SET(connfd, &allset); //将已连接的socket描述符加入allset描述符集中
			if (i > cliarr.maxi)
				cliarr.maxi = i;
			if (connfd > cliarr.maxfd)
				cliarr.maxfd = connfd;

			if (--nready <= 0) {	//如果没有其他的可读就绪，进入下一次检测
				continue;
			}
		}
		/*read clients*/
		for (i = 0; i <= cliarr.maxi; i ++) {
			if (cliarr.clifd[i] < 0){ 
				continue;
			}
			if (FD_ISSET(cliarr.clifd[i], &rset)) {// 已连接的socket读准备就绪
				if (0 == (n=read(cliarr.clifd[i], buf, BSIZE))) { //客户输入ctrl+D或者ctrl+C，即客户关闭
					/*client close the socket*/
					close(cliarr.clifd[i]);
					FD_CLR(cliarr.clifd[i], &allset);
					cliarr.clifd[i] = -1;
					printf("<IP:%s @PORT:%d exit>\n", inet_ntoa(cliarr.cliad[i]->sin_addr), \
							ntohs(cliarr.cliad[i]->sin_port), buf);
					free(cliarr.cliad[i]);
					cliarr.cliad[i] = NULL;
				} else { //显示读取到的信息
					buf[n] = '\0';
					printf("IP:%s @PORT:%d# %s", inet_ntoa(cliarr.cliad[i]->sin_addr), \
							ntohs(cliarr.cliad[i]->sin_port), buf);
				}
				if (--nready <= 0) //如果没有已连接的socket可读，则进入下一次检测
					break;
			}
		}
		while (cliarr.clifd[cliarr.maxi]<0 && cliarr.maxi>=0)
			cliarr.maxi --;
	}
}

客户端的代码：

int main(int argc, char **argv)
{
	int sockfd;
	struct sockaddr_in servaddr;
	
	if (2 != argc) {
		printf("usage: ./client 127.0.0.1");
		return -1;
	}
	/*socket*/
	sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if (-1 == sockfd) {
		perror("socket error.");
		return -1;
	}
	/*connect*/
	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(1234);
	inet_pton(AF_INET, argv[1], &servaddr.sin_addr);
	if (-1 == connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr))) {
		perror("connect error.");
		return -1;
	}

	str_cli(stdin, sockfd);

	return 0;
}

#define LSIZE 100
void str_cli(FILE *fp, int sockfd) //仅仅发送数据到服务器
{
	char sendline[LSIZE], recvline[LSIZE];

	while (NULL != fgets(sendline, LSIZE, fp)) {
		n_write(sockfd, sendline, strlen(sendline));
	}
}

运行结果：

……