147 Linux 网络编程3 ,高并发服务器 --多路I/O转接服务器 - select

从前面的知识学习了如何通过socket ,多进程,多线程创建一个高并发服务器,但是在实际工作中,我们并不会用到前面的方法 去弄一个高并发服务器,有更加好用的方法,就是多路I/O转接器

零 多路I/O转接服务器

多路IO转接服务器也叫做多任务IO服务器。该类服务器实现的主旨思想是,不再由应用程序自己监视客户端连接,取而代之由内核替应用程序监视文件。

主要使用的方法有三种 select , poll , epoll

其中select 可以跨平台

poll 和 epoll不能跨平台,只能在linux上使用。

重点是epoll

次重点是 select

poll知道就行了,再学习后我们会知道原因。

本章主要学习 select。

一 select

  1. select能监听的文件描述符个数受限于FD_SETSIZE,一般为1024,单纯改变进程打开的文件描述符个数并不能改变select监听文件个数
  2. 解决1024以下客户端时使用select是很合适的,但如果链接客户端过多,select采用的是轮询模型,会大大降低服务器响应效率,不应在select上投入更多精力。

select 函数借助内核监听两件事,:客户端连接,数据通信事件。

核心函数: select函数 ,FD_CLR,FD_ISSET,FD_SET,FD_ZERO

int select(int nfds, fd_set *readfds, fd_set *writefds,

fd_set *exceptfds, struct timeval *timeout);

void FD_CLR(int fd, fd_set *set); //把文件描述符集合里fd位清0

int FD_ISSET(int fd, fd_set *set); //测试文件描述符集合里fd是否置1

void FD_SET(int fd, fd_set *set); //把文件描述符集合里fd位置1

void FD_ZERO(fd_set *set); //把文件描述符集合里所有位清0

#include <sys/select.h>
/* According to earlier standards */
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
int select(int nfds, fd_set *readfds, fd_set *writefds,
			fd_set *exceptfds, struct timeval *timeout);

	nfds: 		监控的文件描述符集里最大文件描述符加1,因为此参数会告诉内核检测前多少个文件描述符的状态
	readfds:	监控有读数据到达文件描述符集合,传入传出参数
	writefds:	监控写数据到达文件描述符集合,传入传出参数
	exceptfds:	监控异常发生达文件描述符集合,如带外数据到达异常,传入传出参数
	timeout:	定时阻塞监控时间,3种情况
				1.NULL,永远等下去
				2.设置timeval,等待固定时间
				3.设置timeval里时间均为0,检查描述字后立即返回,轮询
	struct timeval {
		long tv_sec; /* seconds */
		long tv_usec; /* microseconds */
	};
	void FD_CLR(int fd, fd_set *set); 	//把文件描述符集合里fd位清0
	int FD_ISSET(int fd, fd_set *set); 	//测试文件描述符集合里fd是否置1
	void FD_SET(int fd, fd_set *set); 	//把文件描述符集合里fd位置1
	void FD_ZERO(fd_set *set); 			//把文件描述符集合里所有位清0

返回值:所有监听的集合中,满足事件发生的总数

server 端代码实现1

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <ctype.h>
#include <sys/types.h>         
#include <sys/socket.h>
#include <errno.h>
#include <sys/select.h>


#include "wrap.h"

//select 实现高并发代码示例
int main() {
	int listenfd;

	int ret = 0;
	//第一步:创建socket。 打开一个网络通讯端口,如果成功的话,就像open()一样返回一个文件描述符,应用程序可以像读写文件一样用read/write在网络上收发数据,如果socket()调用出错则返回-1

	listenfd = Socket(AF_INET, SOCK_STREAM, 0);

	//第二步 build IP+PORT到网络地址 到socket 创建出来的listenfd
	struct sockaddr_in servaddr;
	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(8000);

	Bind(listenfd, (struct sockaddr *) &servaddr,sizeof(servaddr));
	
	//第三步,设置可以同时监听的最大的数量为1024
	Listen(listenfd, 1024);

	//第四步,这时候 
	//void FD_CLR(int fd, fd_set *set);
	//int  FD_ISSET(int fd, fd_set *set);
	//void FD_SET(int fd, fd_set *set);
	//void FD_ZERO(fd_set *set);

	fd_set readfds;
	FD_ZERO(&readfds);
	FD_SET(listenfd, &readfds);
	fd_set allfds =  readfds;

	int maxfd = listenfd;

	//第五步,这时候就要弄一个循环去监听了。
	//第一次的时候,肯定是只监听了listenfd一个,都是后面,如果有cfd连接上的话,那就监听的多了
	//因此要使用一个maxfd 作为备份记录
	//select 函数的意义是:
//	int select(int nfds, fd_set *readfds, fd_set *writefds,
//		fd_set *exceptfds, struct timeval *timeout);
//
//	nfds: 		监控的文件描述符集里最大文件描述符加1,因为此参数会告诉内核检测前多少个文件描述符的状态
//	readfds:	监控有读数据到达文件描述符集合,传入传出参数
//	writefds:	监控写数据到达文件描述符集合,传入传出参数
//	exceptfds:	监控异常发生达文件描述符集合, 如带外数据到达异常,传入传出参数
//	timeout:	定时阻塞监控时间,3种情况
//	1.NULL,永远等下去
//	2.设置timeval,等待固定时间
//	3.设置timeval里时间均为0,检查描述字后立即返回,轮询
//	struct timeval {
//	long tv_sec; /* seconds */
//	long tv_usec; /* microseconds */
//};返回值:所有监听的集合中,满足事件发生的总数

	int nready = 0;
	struct sockaddr_in clie_addr;
	int clie_addrlen = sizeof(clie_addr);
	int connectfd = 0;
	char buf[BUFSIZ];
	char str[INET_ADDRSTRLEN];

	while (1) {
		readfds = allfds;
		nready = select(maxfd + 1, &readfds,NULL,NULL,NULL);
		//nready为所有监听的集合中,满足事件发生的总数
		//第三个参数timeval我们设置的是NULL,表示阻塞等待
		//因此如果有事件发生,那么就会走到后面的代码,且readfds集合中会改动成为真正
		//有监听事件发生后,第一步做错误判断处理
		if (nready < 0 ) {
			//说明有error发生
			perr_exit("select error");
		}
		//第六步,判断nready中是否有 新的连接事件发生,也就是说listenfd是否
		if (FD_ISSET(listenfd, &readfds)) {
			//走到这里,说明有新的链接过来了,那么我们要做如下的几件事
			//6.1 server赶紧连接,注意,这时候并不会阻塞,因为listenfd已经有了读取事件才会走到这里
			connectfd = Accept(listenfd, (struct sockaddr *)&clie_addr, &clie_addrlen);
			//这里加一行log,目的是将连接的客户端的信息打印出来
			printf("received from %s at PORT %d\n",
				inet_ntop(AF_INET, &clie_addr.sin_addr, str, sizeof(str)),
				ntohs(clie_addr.sin_port));
			//这里添加一行判断,如果connectedfd已经超过1024,则不支持,select对于每个进程或者线程只能支持最多1024个
			if (connectfd == FD_SETSIZE) { /* 达到select能监控的文件个数上限 1024 */
				fputs("too many clients\n", stderr);
				exit(1);
			}
			//6.2 将这个新的链接添加到 监听的readfds中

			FD_SET(connectfd,&allfds); /* 向监控文件描述符集合allset添加新的文件描述符connfd */
		

			//6.3 更新maxfd
			if (connectfd > maxfd) {
				maxfd = connectfd;    /* 有可能最大的connectfd 需要变化,这是因为当有新的connectfd之前,如果没有任何的connectfd没有断开,则会变成最大,但是如果中间有connect断开,则这个新的connectfd的值,有可能不是最大。select第一个参数需要 */
									//假设之前来了,4,5,6,这时候客户端4已经断开了,这时候 connectfd就等于4,如果4,5,6都没有断开过,则这时候新来的会是7
			}

			//6.4 判断select 的返回值 是否只有一个,且是listenfd事件,如果走到这里说明这一个已经被处理了,因此就没有必要往下再执行了
			if (--nready == 0 ) {
				continue;
			}

		}



		//第七步,走到这里说明nready中有一个或者多个 客户端发送数据的事件过来。
		//我们当前的写法是通过循环1024次,挨个往出拿,/* 检测哪个clients 有数据就绪 */
		char buf[BUFSIZ] = {0};
		int realreadnum = 0;
		for (int i = listenfd+1; i < 1024;++i) {
			bzero(buf, BUFSIZ);
			if (FD_ISSET(i, &readfds)) {
			REREADPOINT:
				realreadnum = Read(i, buf, BUFSIZ); //真正的读取到了数据
				if (realreadnum == 0 ) {//在网络环境下,read函数返回0,说明是对端关闭了,也就是说,客户端关闭了
					//那么就应该关闭当前的connect端,并将该监听从 allfds中 移除
					Close(i);
					FD_CLR(i, &allfds);
				}
				else if (realreadnum == -1) {
					
					if (errno == EINTR) {
						//说明是被信号打断的,一般要重新read
						printf("信号打断\n");
						goto REREADPOINT;
					}
					else if(errno == EAGAIN || errno == EWOULDBLOCK)
					{
						printf(" WOULDBLOCK \n");
						//说明在打开文件的时候是使用的O_NONBLOCK方式打开的,但是没有读取到数据
						//当前代码是不会走到这里的,因为前面代码select的最后一个参数用的NULL,是阻塞的
						//一般在这里 也要重新读,但是这里有个问题,如果一直都读取不到,会不会死循环?
						goto REREADPOINT;
					}
					else if (errno == ECONNRESET) {
						//ECONNRESET 说明连接被重置了,因此要将该cfd关闭,并重新移除监听队列
						Close(i);
						FD_CLR(i, &allfds);
					}
					else {
						//这就是真正的有问题了,注意这里不要exit程序,应该只是让打印log
						//不退出程序是因为,这时候还有其他的链接连上的
						perror("read num <0");
					}
				}
				else if (realreadnum > 0 ) {
					//真正的读取到了客户端发送过来的数据
					for (int j = 0; j < realreadnum;++j) {
						buf[j] = toupper(buf[j]);
					}
					Write(i, buf,realreadnum);
					Write(STDOUT_FILENO,buf,realreadnum);
				}
				if (--nready == 0) { //有可能50个已经连接上的链接中,这时候只有3个有数据发送过来了,还是要从50个中遍历,但是不同的是,假设是 5,19,30,那么写这一块代码就能节省时间了,当遍历到30后,--nready 就会等于0,直接跳出
					break;    /* 跳出for, 但还在while中 */
				}
			}
		}

	}


	return ret;

}

server 端代码优化

可以看到,select函数在有客户端和服务器端沟通的过程中,需要依次遍历对比知道具体是哪一个connectfd有数据发送过来,这很影响工作效率,因此有了如下的优化。

优化的整体思路是:当有了connectfd链接后,就将这些connectfd记录到另一个数组中,并记录这个数组的最大下标。当客户端的链接断开的时候,则将当前的下标重置

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <ctype.h>
#include <sys/types.h>         
#include <sys/socket.h>
#include <errno.h>
#include <sys/select.h>


#include "wrap.h"
//从select1.c我们看到,代码还有可以完善的地方,这里就完善一下
//1.最后每次都要循环1020次,遍历查看哪些cfd有数据发送过来,这是不合理的
//因此我们需要搞一个数组,用这个数组记录真正的有数据访问的cfd
//并且弄一个int 值,记录这个数组的最大下标 maxi

//select 实现高并发代码示例
int main() {
	int listenfd;
	//额外添加代码 start
	int client[FD_SETSIZE];  /* 自定义数组client, 防止遍历1024个文件描述符  FD_SETSIZE默认为1024 */
	int maxi;

	maxi = -1;                                                  /* 将来用作client[]的下标, 初始值指向0个元素之前下标位置 */
	for (int i = 0; i < FD_SETSIZE; i++)
		client[i] = -1;                                         /* 用-1初始化client[] */

	//额外添加代码 end

	int ret = 0;
	//第一步:创建socket。 打开一个网络通讯端口,如果成功的话,就像open()一样返回一个文件描述符,应用程序可以像读写文件一样用read/write在网络上收发数据,如果socket()调用出错则返回-1

	listenfd = Socket(AF_INET, SOCK_STREAM, 0);

	//端口复用的代码添加上,端口复用的代码需要写在bind之前,socket之后
	int opt = 1; //1表示可以让端口复用,0表示不让端口复用

	setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

	//第二步 build IP+PORT到网络地址 到socket 创建出来的listenfd
	struct sockaddr_in servaddr;
	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(8000);

	Bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr));

	//第三步,设置可以同时监听的最大的数量为1024
	Listen(listenfd, 1024);

	//第四步,这时候 
	//void FD_CLR(int fd, fd_set *set);
	//int  FD_ISSET(int fd, fd_set *set);
	//void FD_SET(int fd, fd_set *set);
	//void FD_ZERO(fd_set *set);

	fd_set readfds;
	FD_ZERO(&readfds);
	FD_SET(listenfd, &readfds);
	fd_set allfds = readfds;

	int maxfd = listenfd;

	//第五步,这时候就要弄一个循环去监听了。
	//第一次的时候,肯定是只监听了listenfd一个,都是后面,如果有cfd连接上的话,那就监听的多了
	//因此要使用一个maxfd 作为备份记录
	//select 函数的意义是:
//	int select(int nfds, fd_set *readfds, fd_set *writefds,
//		fd_set *exceptfds, struct timeval *timeout);
//
//	nfds: 		监控的文件描述符集里最大文件描述符加1,因为此参数会告诉内核检测前多少个文件描述符的状态
//	readfds:	监控有读数据到达文件描述符集合,传入传出参数
//	writefds:	监控写数据到达文件描述符集合,传入传出参数
//	exceptfds:	监控异常发生达文件描述符集合, 如带外数据到达异常,传入传出参数
//	timeout:	定时阻塞监控时间,3种情况
//	1.NULL,永远等下去
//	2.设置timeval,等待固定时间
//	3.设置timeval里时间均为0,检查描述字后立即返回,轮询
//	struct timeval {
//	long tv_sec; /* seconds */
//	long tv_usec; /* microseconds */
//};返回值:所有监听的集合中,满足事件发生的总数

	int nready = 0;
	struct sockaddr_in clie_addr;
	int clie_addrlen = sizeof(clie_addr);
	int connectfd = 0;
	char buf[BUFSIZ];
	char str[INET_ADDRSTRLEN];

	while (1) {
		readfds = allfds;
		nready = select(maxfd + 1, &readfds, NULL, NULL, NULL);
		//nready为所有监听的集合中,满足事件发生的总数
		//第三个参数timeval我们设置的是NULL,表示阻塞等待
		//因此如果有事件发生,那么就会走到后面的代码,且readfds集合中会改动成为真正
		//有监听事件发生后,第一步做错误判断处理
		if (nready < 0) {
			//说明有error发生
			perr_exit("select error");
		}
		//第六步,判断nready中是否有 新的连接事件发生,也就是说listenfd是否
		if (FD_ISSET(listenfd, &readfds)) {
			//走到这里,说明有新的链接过来了,那么我们要做如下的几件事
			//6.1 server赶紧连接,注意,这时候并不会阻塞,因为listenfd已经有了读取事件才会走到这里
			connectfd = Accept(listenfd, (struct sockaddr *)&clie_addr, &clie_addrlen);
			//这里加一行log,目的是将连接的客户端的信息打印出来
			printf("received from %s at PORT %d\n",
				inet_ntop(AF_INET, &clie_addr.sin_addr, str, sizeof(str)),
				ntohs(clie_addr.sin_port));

			//额外添加代码 start
			int i = 0;
			for (; i < FD_SETSIZE; i++)
				if (client[i] < 0) {                            /* 找client[]中没有使用的位置 */
					client[i] = connectfd;                         /* 保存accept返回的文件描述符到client[]里 */
					break;
				}
			//额外添加代码 end
			//这里添加一行判断,如果connectedfd已经超过1024,则不支持,select对于每个进程或者线程只能支持最多1024个
			if (connectfd == FD_SETSIZE) { /* 达到select能监控的文件个数上限 1024 */
				fputs("too many clients\n", stderr);
				exit(1);
			}
			//6.2 将这个新的链接添加到 监听的readfds中

			FD_SET(connectfd, &allfds); /* 向监控文件描述符集合allset添加新的文件描述符connfd */


			//6.3 更新maxfd
			if (connectfd > maxfd) {
				maxfd = connectfd;    /* 有可能最大的connectfd 需要变化,这是因为当有新的connectfd之前,如果没有任何的connectfd没有断开,则会变成最大,但是如果中间有connect断开,则这个新的connectfd的值,有可能不是最大。select第一个参数需要 */
									//假设之前来了,4,5,6,这时候客户端4已经断开了,这时候 connectfd就等于4,如果4,5,6都没有断开过,则这时候新来的会是7
			}
			//额外添加代码 start
			if (i > maxi) {
				maxi = i;           /* 保证maxi存的总是client[]最后一个元素下标 */
			}
			//额外添加代码 end


			//6.4 判断select 的返回值 是否只有一个,且是listenfd事件,如果走到这里说明这一个已经被处理了,因此就没有必要往下再执行了
			if (--nready == 0) {
				continue;
			}

		}



		//第七步,走到这里说明nready中有一个或者多个 客户端发送数据的事件过来。
		//我们当前的写法是通过循环1024次,挨个往出拿,/* 检测哪个clients 有数据就绪 */
		char buf[BUFSIZ] = { 0 };
		int realreadnum = 0;
		//for (int i = listenfd + 1; i < 1024; ++i) {
		//	bzero(buf, BUFSIZ);
		//	if (FD_ISSET(i, &readfds)) {
		//	REREADPOINT:
		//		realreadnum = Read(i, buf, BUFSIZ); //真正的读取到了数据
		//		if (realreadnum == 0) {//在网络环境下,read函数返回0,说明是真的读取到文件末尾了
		//			//既然已经读取到了文件末尾,那么就应该关闭当前的connect端,并将该监听从 allfds中 移除
		//			Close(i);
		//			FD_CLR(i, &allfds);
		//		}
		//		else if (realreadnum == -1) {

		//			if (errno == EINTR) {
		//				//说明是被信号打断的,一般要重新read
		//				printf("信号打断\n");
		//				goto REREADPOINT;
		//			}
		//			else if (errno == EAGAIN || errno == EWOULDBLOCK)
		//			{
		//				printf(" WOULDBLOCK \n");
		//				//说明在打开文件的时候是使用的O_NONBLOCK方式打开的,但是没有读取到数据
		//				//当前代码是不会走到这里的,因为前面代码select的最后一个参数用的NULL,是阻塞的
		//				//一般在这里 也要重新读,但是这里有个问题,如果一直都读取不到,会不会死循环?
		//				goto REREADPOINT;
		//			}
		//			else if (errno == ECONNRESET) {
		//				//ECONNRESET 说明连接被重置了,因此要将该cfd关闭,并重新移除监听队列
		//				Close(i);
		//				FD_CLR(i, &allfds);
		//			}
		//			else {
		//				//这就是真正的有问题了,注意这里不要exit程序,应该只是让打印log
		//				//不退出程序是因为,这时候还有其他的链接连上的
		//				perror("read num <0");
		//			}
		//		}

		//		else if (realreadnum > 0) {
		//			//真正的读取到了客户端发送过来的数据
		//			for (int j = 0; j < realreadnum; ++j) {
		//				buf[j] = toupper(buf[j]);
		//			}
		//			Write(i, buf, realreadnum);
		//			Write(STDOUT_FILENO, buf, realreadnum);
		//		}
		//	}
		//}

		//额外添加代码 start

		int sockfd = 0;
		for (int i = 0; i <= maxi; i++) {  /* 检测哪个clients 有数据就绪 */
			if ((sockfd = client[i]) < 0)
				continue;
			bzero(buf, BUFSIZ);
			if (FD_ISSET(sockfd, &readfds)) {
			REREADPOINT:
				realreadnum = Read(sockfd, buf, BUFSIZ); //真正的读取到了数据
				if (realreadnum == 0) {//在网络环境下,read函数返回0,说明是对端关闭了,也就是说,客户端关闭了
					//那么就应该关闭当前的connect端,并将该监听从 allfds中 移除
					Close(sockfd);
					FD_CLR(sockfd, &allfds);
					printf("read done\n");
					//额外添加的代码 start
					client[i] = -1;
					//额外添加的代码 end
				}
				else if (realreadnum == -1) {

					if (errno == EINTR) {
						//说明是被信号打断的,一般要重新read
						printf("信号打断\n");
						goto REREADPOINT;
					}
					else if (errno == EAGAIN || errno == EWOULDBLOCK)
					{
						printf(" WOULDBLOCK \n");
						//说明在打开文件的时候是使用的O_NONBLOCK方式打开的,但是没有读取到数据
						//当前代码是不会走到这里的,因为前面代码select的最后一个参数用的NULL,是阻塞的
						//一般在这里 也要重新读,但是这里有个问题,如果一直都读取不到,会不会死循环?
						goto REREADPOINT;
					}
					else if (errno == ECONNRESET) {
						//ECONNRESET 说明连接被重置了,因此要将该cfd关闭,并重新移除监听队列
						Close(sockfd);
						FD_CLR(sockfd, &allfds);
						//额外添加的代码 start
						client[i] = -1;
						//额外添加的代码 end
					}
					else {
						//这就是真正的有问题了,注意这里不要exit程序,应该只是让打印log
						//不退出程序是因为,这时候还有其他的链接连上的
						perror("read num <0");
					}
				}

				else if (realreadnum > 0) {
					//真正的读取到了客户端发送过来的数据
					for (int j = 0; j < realreadnum; ++j) {
						buf[j] = toupper(buf[j]);
					}
					Write(sockfd, buf, realreadnum);
					Write(STDOUT_FILENO, buf, realreadnum);
				}
				if (--nready == 0) { //有可能50个已经连接上的链接中,这时候只有3个有数据发送过来了,还是要从50个中遍历,但是不同的是,假设是 5,19,30,那么写这一块代码就能节省时间了,当遍历到30后,--nready 就会等于0,直接跳出
					break;    /* 跳出for, 但还在while中 */
				}
			}
		}
		//额外添加代码 end

}


	return ret;

}
相关推荐
饮啦冰美式1 分钟前
22.04Ubuntu---ROS2使用rclcpp编写节点
linux·运维·ubuntu
wowocpp1 分钟前
ubuntu 22.04 server 安装 和 初始化 LTS
linux·运维·ubuntu
wowocpp2 分钟前
ubuntu 22.04 server 格式化 磁盘 为 ext4 并 自动挂载 LTS
服务器·数据库·ubuntu
wclass-zhengge5 分钟前
Netty篇(入门编程)
java·linux·服务器
Lign173147 分钟前
ubuntu unrar解压 中文文件名异常问题解决
linux·运维·ubuntu
方方怪11 分钟前
与IP网络规划相关的知识点
服务器·网络·tcp/ip
大霞上仙1 小时前
Ubuntu系统电脑没有WiFi适配器
linux·运维·电脑
weixin_442643421 小时前
推荐FileLink数据跨网摆渡系统 — 安全、高效的数据传输解决方案
服务器·网络·安全·filelink数据摆渡系统
Karoku0661 小时前
【企业级分布式系统】Zabbix监控系统与部署安装
运维·服务器·数据库·redis·mysql·zabbix
为什么这亚子1 小时前
九、Go语言快速入门之map
运维·开发语言·后端·算法·云原生·golang·云计算