并发服务器select

最新推荐文章于 2024-01-18 15:47:05 发布

chmy1992

最新推荐文章于 2024-01-18 15:47:05 发布

阅读量279

点赞数

分类专栏： linux网络编程

本文链接：https://blog.csdn.net/chmy1992/article/details/76599508

版权

linux网络编程专栏收录该内容

23 篇文章 0 订阅

订阅专栏

思想：

用select管理多个IO，一旦其中一个IO或者多个IO检测到我们感兴趣的时间，select函数返回，返回值为检测到的事件个数。并且会返回哪些IO发生了事件，遍历这些事假然后处理它。

函数

int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
[1] nfds表示存放到这些集合的描述符的最大值加1，比如readfds存的是3，5，8，write中存放的是4，9，exception填空指针，那么此时最大描述符为9，那么nfds就是10。
[2] readfds，读集合
发生条件：
1) 套接口缓冲区有数据刻度
2) 套接口的读一半关闭，解接收FIN段，读操作返回0
3) 如果是监听套接口，已完成连接队列不为空时
4) 套接口上发生了一个错误待处理，错误可通过getstock指定SO_ERROR选项来获取
[3] writefds，写集合
发生条件：
1) 套接口发送缓冲区有空间接纳数据
2) 连接的写一半关闭，即接收到RST段之后，再次调用write操作，此时会产生SIGPIPE信号
3) 套接口上发生了一个错误待处理，错误可通过getstock指定SO_ERROR选项来获取
[4] 异常集合
发生条件：
1) 套接口存在外带数据
[5] 超时时间结构体
void FD_CLR(int fd, fd_set *set)，将文件描述符从集合中移除
int FD_ISEET(int fd, fd_set *set)，判断文件描述符是否在集合中，用来判断对应的文件描述符发生了变化
void FD_SET(int fd, fd_set *set)，将文件描述符添加到集合中

void FD_ZERO(fd_set *set)，清空集合

问题

select会受到FD_SETSIZE的限制，监听的端口会有限，因为select本质是轮训模式，如果监听的端口比较多，那么效率可能会很低，因此端口数量不能很多。

服务器端：

#include<unistd.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<sys/wait.h>
#include<stdlib.h>
#include<stdio.h>
#include<errno.h>
#include<string.h>
#include<signal.h>
#define ERR_EXIT(m) do{perror(m);exit(EXIT_FAILURE);}while(1)
struct packet
{
	int len;
	char buf[1024];
};
ssize_t readn(int fd, void *buf, size_t count)
{
	size_t nleft = count;
	ssize_t nread;
	char *bufp = (char*)buf;
	while (nleft > 0)
	{
		if ((nread = read(fd, bufp, nleft)) < 0)
		{
			if (errno == EINTR)
			{
				continue;
				return -1;
			}
			else if (nread == 0)return count - nleft;
		}
		bufp = bufp + nread;
		nleft = nleft - nread;
	}
	return count;
}
ssize_t writen(int fd, void *buf, size_t count)
{
	size_t nleft = count;
	ssize_t nwrite;
	char *bufp = (char*)buf;
	while (nleft > 0)
	{
		if ((nwrite = write(fd, bufp, nleft)) < 0)
		{
			if (errno == EINTR)
			{
				continue;
				return -1;
			}
			else if (nwrite == 0)continue;
		}
		bufp = bufp + nwrite;
		nleft = nleft - nwrite;
	}
	return count;
}
ssize_t recv_peek(int sockfd, void *buf, size_t len)
{
	while (1)
	{
		int ret = recv(sockfd, buf, len, MSG_PEEK);
		if (ret == -1 && errno == EINTR)continue;
		return ret;
	}
}
ssize_t readline(int sockfd, void *buf, size_t maxline)
{
	int ret;
	int nread;
	char *bufp = (char*)buf;
	int nleft = maxline;
	while (1)
	{
		ret = recv_peek(sockfd, bufp, nleft);
		if (ret < 0)return ret;
		else if (ret == 0)return ret;//对方关闭了套接口
		nread = ret;
		for (int i = 0; i < nread; i++)
		{
			if (bufp[i] == '\n')
			{
				ret = readn(sockfd, bufp, i + 1);//将缓冲区数据移除
				if (ret != i + 1)exit(EXIT_FAILURE);
				return ret;
			}
		}
		if (nread>nleft)exit(EXIT_FAILURE);//读到的数据不能超过缓冲区
		nleft -= nread;
		ret = readn(sockfd, bufp, nread);
		if (ret != nread)exit(EXIT_FAILURE);
		bufp += nread;
	}
	return -1;
}
void do_service(int connfd)
{
	char recvbuf[1024];
	int n;
	while (1)
	{
		memset(&recvbuf, 0, sizeof(recvbuf));
		int ret = readline(connfd, recvbuf, 1204);
		if (ret == -1)
		{
			ERR_EXIT("read");
		}
		else if (ret == 0)
		{
			printf("client cloase\n");
			break;
		}
		fputs(recvbuf, stdout);
		writen(connfd, recvbuf, strlen(recvbuf));
	}
}
void handle_sigchild(int sig)
{
//  wait(NULL);
   while(waitpid(-1,NULL,WNOHANG)>0);//
}
int main(void)
{
	//signal(SIGCHLD, SIG_IGN);
	signal(SIGCHLD,handle_sigchild);
        int listenfd;
	if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)ERR_EXIT("socket");
	struct sockaddr_in servaddr;
	memset(&servaddr, 0, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(5188);
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	int on = 1;
	if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)ERR_EXIT("setsockopt");
	if (bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)ERR_EXIT("bind");
	if (listen(listenfd, SOMAXCONN) < 0)ERR_EXIT("listten");
	/*while (1)
	{
		int connfd;
		struct sockaddr_in peeraddr;
		socklen_t peerlen = sizeof(peeraddr);
		if ((connfd = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen)) < 0)ERR_EXIT("accept");
		printf("ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
		pid_t pid = fork();
		if (pid == -1)ERR_EXIT("fork");
		if (pid == 0)
		{
			close(listenfd);
			do_service(connfd);
			exit(EXIT_SUCCESS);
		}
		if (pid > 0)
		{
			close(connfd);
		}
	}*/
	int client[FD_SETSIZE];//最大处理的数量
	for (int i = 0; i < FD_SETSIZE; i++)client[i] = -1;
	int nready = 0;
    int maxi=0;//最大空闲描述符
	int maxfd = listenfd;//因为此时并没有新的进来，因此此时最大的就是监听套接字
	fd_set rset, allset;
	FD_ZERO(&rset);
	FD_ZERO(&allset);
	FD_SET(listenfd, &allset);
	while (1)
	{
		rset = allset;//因为每次监听后，rset里面的内容会改变
		nready = select(maxfd + 1, &rset, NULL, NULL, NULL);
		if (nready == -1)
		{
			if (errno == EINTR)continue;//被信号中断
			ERR_EXIT("select");
		}
		if (nready == 0)continue;
		if (FD_ISSET(listenfd, &rset))//是否是监听套接口产生了事件
		{
			int connfd;
			struct sockaddr_in peeraddr;
			socklen_t peerlen = sizeof(peeraddr);
			if ((connfd = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen)) < 0)ERR_EXIT("accept");
			int i = 0;
			for ( i = 0; i < FD_SETSIZE; i++)
			{
				if (client[i] == -1)
				{
					client[i] = connfd;//找到空闲位置
				        if(i>maxi)maxi=i;
                                 	break;
				}
			}
			if (i == FD_SETSIZE)
			{
				printf("server is full, too many client\n");
				exit(EXIT_FAILURE);
			}
			printf("ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
			FD_SET(connfd, &allset);
			maxfd = maxfd>connfd ? maxfd : connfd;
			if (--nready <= 0)continue;//检测到的事件已经处理完了
		}
		for (int i = 0; i <= maxi; i++)
		{
			int connfd = client[i];
			if (connfd == -1)continue;
			if (FD_ISSET(connfd, &rset))//判断是否发生了读事件
			{
				//printf("reading.........\n");
				char recvbuf[1024];
				memset(&recvbuf, 0, sizeof(recvbuf));
				int ret = readline(connfd, recvbuf, sizeof(recvbuf));
				if (ret == -1)
				{
					ERR_EXIT("read");
				}
				else if (ret == 0)
				{
					printf("client close\n");
					FD_CLR(connfd, &allset);//套接字已经关闭，从集合中清除
	               client[i]=-1;//设置为空闲
                }
				fputs(recvbuf, stdout);
				writen(connfd, recvbuf, strlen(recvbuf));
				if (--nready <= 0)break;//检测到的事件已经处理完了,重新监听
			}
		}
	}
	close(listenfd);
}

客户端：

#include<unistd.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<stdlib.h>
#include<stdio.h>
#include<errno.h>
#include<string.h>
#define ERR_EXIT(m) do{perror(m);exit(EXIT_FAILURE);}while(0)
struct packet
{
	int len;
	char buf[1024];
};
ssize_t readn(int fd, void *buf, size_t count)
{
	size_t nleft = count;
	ssize_t nread;
	char *bufp = (char*)buf;
	while (nleft > 0)
	{
		if ((nread = read(fd, bufp, nleft)) < 0)
		{
			if (errno == EINTR)
			{
				continue;
				return -1;
			}
			else if (nread == 0)return count - nleft;
		}
		bufp = bufp + nread;
		nleft = nleft - nread;
	}
	return count;
}
ssize_t writen(int fd, void *buf, size_t count)
{
	size_t nleft = count;
	ssize_t nwrite;
	char *bufp = (char*)buf;
	while (nleft > 0)
	{
		if ((nwrite = write(fd, bufp, nleft)) < 0)
		{
			if (errno == EINTR)
			{
				continue;
				return -1;
			}
			else if (nwrite == 0)continue;
		}
		bufp = bufp + nwrite;
		nleft = nleft - nwrite;
	}
	return count;
}
ssize_t recv_peek(int sockfd, void *buf, size_t len)
{
	while (1)
	{
		int ret = recv(sockfd, buf, len, MSG_PEEK);
		if (ret == -1 && errno == EINTR)continue;
		return ret;
	}
}
ssize_t readline(int sockfd, void *buf, size_t maxline)
{
	int ret;
	int nread;
	char *bufp = (char*)buf;
	int nleft = maxline;
	while (1)
	{
		ret = recv_peek(sockfd, bufp, nleft);
		if (ret < 0)return ret;
		else if (ret == 0)return ret;//对方关闭了套接口
		nread = ret;
		for (int i = 0; i < nread; i++)
		{
			if (bufp[i] == '\n')
			{
				ret = readn(sockfd, bufp, i + 1);//将缓冲区数据移除
				if (ret != i + 1)exit(EXIT_FAILURE);
				return ret;
			}
		}
		if (nread>nleft)exit(EXIT_FAILURE);//读到的数据不能超过缓冲区
		nleft -= nread;
		ret = readn(sockfd, bufp, nread);
		if (ret != nread)exit(EXIT_FAILURE);
		bufp += nread;
	}
	return -1;
}
void echo_cli(int sockfd)
{
	char sendbuf[1024];
	char recvbuf[1024];
	memset(sendbuf, 0, sizeof(sendbuf));
	memset(recvbuf, 0, sizeof(recvbuf));
	while (fgets(sendbuf, sizeof(sendbuf), stdin) != NULL)
	{
		writen(sockfd, sendbuf, strlen(sendbuf));
		int ret = readline(sockfd, recvbuf, sizeof(recvbuf));
		if (ret == -1)ERR_EXIT("read");
		if (ret == 0)
		{
			printf("server close\n");
			break;
		}
		fputs(recvbuf, stdout);
		memset(sendbuf, 0, sizeof(sendbuf));
		memset(recvbuf, 0, sizeof(recvbuf));
	}
	close(sockfd);
}
void echo_cli1(int sockfd)
{
	fd_set rset;
	FD_ZERO(&rset);
	int nready;
	int maxfd;
	int fd_stdin = fileno(stdin);
	if (fd_stdin > sockfd)maxfd = fd_stdin;
	else maxfd = sockfd;
	char sendbuf[1024];
	char recvbuf[1024];
	while (1)
	{
		FD_SET(fd_stdin, &rset);
		FD_SET(sockfd, &rset);
		nready = select(maxfd + 1, &rset, NULL, NULL, NULL);
		if (nready == -1)ERR_EXIT("select");
		if (nready == 0)continue;
		if (FD_ISSET(sockfd, &rset))
		{
			int ret = readline(sockfd, recvbuf, sizeof(recvbuf));
			if (ret == -1)ERR_EXIT("read");
			if (ret == 0)
			{
				printf("server close\n");
				break;
			}
			fputs(recvbuf, stdout);
		}
		if (FD_ISSET(fd_stdin, &rset))
		{
			if (fgets(sendbuf, sizeof(sendbuf), stdin) == NULL)break;
			writen(sockfd, sendbuf, strlen(sendbuf));
		}
		memset(sendbuf, 0, sizeof(sendbuf));
		memset(recvbuf, 0, sizeof(recvbuf));
	}
	close(sockfd);
}
int main(void)
{
	int sockfd;
	if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)ERR_EXIT("socket");
	struct sockaddr_in servaddr;
	memset(&servaddr, 0, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(5188);
	servaddr.sin_addr.s_addr = inet_addr("127.0.1");
	if (connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)ERR_EXIT("bind");
	echo_cli1(sockfd);
}