Android系统原理性问题分析 - 多路并发情况下的C/S模型

news2024/11/25 1:02:35

声明

  • 在Android系统中经常会遇到一些系统原理性的问题，在此专栏中集中来讨论下。
  • Android系统中很多地方都采用了I/O多路复用的机制，为了引出I/O多路复用机制，先来分析多路并发情况下的C/S模型。
  • 此篇参考一些博客和书籍，代码基于Android 7.1.1，不方便逐一列出，仅供学习、知识分享。
  • 此篇代码下载：多路并发情况下的C/S模型实例

1 概述

  假设有一个将 INET 套接字用作 C/S 模型。如果想让一个Server端与多个 Client端通信，那么每个Server端 和 Client端都需要 INET 套接字。如果多客户端同时连接服务器端，那服务器端如何处理多客户端的服务请求呢？ C/S模型通常有三种处理方式：多进程、多线程、I/O 多路复用。

2 多路并发情况下的C/S模型

  通常利用多进程或多线程的方式进行进程或线程与多个客户端通信的操作，并处理服务请求。这种方式比较直观，但由于要使用IPC 或互斥量对进程及线程进行同步，所以进程或线程数量越多，编程就会变得越复杂。另外，生成进程和线程需要很多资源。

2.1 多进程模型

2.1.1 多进程模型框架

  多进程模型接收到来自客户端的连接请求后，调用 fork() 函数生成处理连接请求的新进程。fork() 通常在 Linux 环境下复制一个程序本身，然后同时处理多个操作。下图为 Server 端的多进程模型。Server 端进程对各 Client 端的连接请求生成新的 worker 进程进行处理。worker 进程并行处理Client 的请求。
在这里插入图片描述
  多进程模型是 Heavy-Weight 模型，通过 fork 生成新进程后，需要在新的内存区域生成并复制父进程内的所有数据结构。调用 fork() 函数生成进程会消耗很多系统资源，多进程也需要在相互独立的内存空间中运行，所以需要进程间的 IPC，程序也会随之变得更加复杂。

使用多进程并发服务器时要考虑以下几点：

  1. 父进程最大文件描述个数(父进程中需要关闭accept返回的新文件描述符)
  2. 系统内创建进程个数(与内存大小相关)
  3. 进程创建过多是否降低整体服务性能(进程调度)

2.1.2 多进程模型代码实例

2.1.2.1 Server端代码

/* server.c */

#include <stdio.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <ctype.h>
#include <unistd.h>
#include "wrap.h"

#define MAXLINE 80
#define SERV_PORT 8888

void do_sigchild(int num)
{
	while (waitpid(0, NULL, WNOHANG) > 0)
		;
}

int main(void)
{
	struct sockaddr_in servaddr, cliaddr;
	socklen_t cliaddr_len;
	int listenfd, connfd;
	char buf[MAXLINE];
	char str[INET_ADDRSTRLEN];
	int i, n;
	pid_t pid;

	//设置SIGCHLD信号的处理函数,用来回收执行结束子进程
	struct sigaction newact;
	newact.sa_handler = do_sigchild;
	sigemptyset(&newact.sa_mask);
	newact.sa_flags = 0;
	sigaction(SIGCHLD, &newact, NULL);
	
	//创建服务端socket
	listenfd = Socket(AF_INET, SOCK_STREAM, 0);

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(SERV_PORT);

	//绑定服务端的socket
	Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
	//设置监听socket，最大监听数为：20
	Listen(listenfd, 20);

	printf("Accepting connections ...\n");
	while (1) {
		cliaddr_len = sizeof(cliaddr);
		//等待客户端连接
		connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);

		pid = fork();
		//进入子进程
		if (pid == 0) {
			//关闭子进程中继承来的服务端监听socket
			Close(listenfd);
			//在while循环中处理客户端的请求
			while (1) {
				n = Read(connfd, buf, MAXLINE);
				if (n == 0) {
					printf("the other side has been closed.\n");
					break;
				}
				printf("received from %s at PORT %d\n",
						inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),
						ntohs(cliaddr.sin_port));
				for (i = 0; i < n; i++)
					buf[i] = toupper(buf[i]);
				Write(connfd, buf, n);
			}
			//关闭客户端连接socket
			Close(connfd);
			return 0;
		//进入父进程
		} else if (pid > 0) {
			//关闭客户端连接socket
			Close(connfd);
		} else
			perr_exit("fork");
	}
	Close(listenfd);
	return 0;
}

2.1.2.2 Client端代码

/* client.c */

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "wrap.h"

#define MAXLINE 80
#define SERV_PORT 8888

int main(int argc, char *argv[])
{
	struct sockaddr_in servaddr;
	char buf[MAXLINE];
	int sockfd, n;
	//创建客户端中的socket，其为服务端在客户端中代表
	sockfd = Socket(AF_INET, SOCK_STREAM, 0);

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
	servaddr.sin_port = htons(SERV_PORT);

	//连接服务端
	Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

	//通过sockfd向服务端发送请求，并接收返回信息
	while (fgets(buf, MAXLINE, stdin) != NULL) {
		Write(sockfd, buf, strlen(buf));
		n = Read(sockfd, buf, MAXLINE);
		if (n == 0) {
			printf("the other side has been closed.\n");
			break;
		} else
			Write(STDOUT_FILENO, buf, n);
	}
	//通信结束后，关闭socket
	Close(sockfd);
	return 0;
}

2.2 多线程模型

2.2.1 多线程模型框架

  多线程是Light-Weight 模型，不生成新进程，而是共享进程的大部分资源，只需要线程的数据结构（局部变量、保存寄存器的空间、栈、PC 等），这样就解决了多进程模型存在的问题。使用多线程时，多线程的生成及上下文切换消耗较少，速度又快，且不需要其他 IPC 即可通过共享资源进行通信。最后，在CPU多核环境中各线程可以在不同Core中并行，所以对CPU多核环境而言非常有用。

  下图的是Server 端进程的多线程模型。每当Server 端进程收到来自Client 端的连接请求时，都会生成新线程，或使用线程池中等待的线程，以处理各Client 端的服务请求。
在这里插入图片描述
  多线程模型也存在缺点：一个线程的死亡会对该线程所在的整个进程产生很大影响，很难推测各线程中哪个先运行，也就很难进行调试。

在使用线程模型开发服务器时需考虑以下问题：

  1. 调整进程内最大文件描述符上限
  2. 线程如有共享数据，考虑线程同步
  3. 服务在客户端线程退出时，退出处理（退出值，分离态）
  4. 系统负载，随着链接客户端增加，导致其它线程不能及时得到CPU

2.2.2 多线程模型代码实例

2.2.2.1 Server端代码

/* server.c */

#include <stdio.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <ctype.h>
#include <unistd.h>
#include <fcntl.h>
#include "wrap.h"

#define MAXLINE 80
#define SERV_PORT 8888

struct s_info {
	struct sockaddr_in cliaddr;
	int connfd;
};

//线程函数
void *do_work(void *arg)
{
	int n,i;
	struct s_info *ts = (struct s_info*)arg;
	char buf[MAXLINE];
	char str[INET_ADDRSTRLEN];
	/* 可以在创建线程前设置线程创建属性,设为分离态,哪种效率高内？ */
	pthread_detach(pthread_self());
	//在while循环中处理客户端的请求
	while (1) {
		n = Read(ts->connfd, buf, MAXLINE);
		if (n == 0) {
			printf("the other side has been closed.\n");
			break;
		}
		printf("received from %s at PORT %d\n",
				inet_ntop(AF_INET, &(*ts).cliaddr.sin_addr, str, sizeof(str)),
				ntohs((*ts).cliaddr.sin_port));
		for (i = 0; i < n; i++)
			buf[i] = toupper(buf[i]);
		Write(ts->connfd, buf, n);
	}
	Close(ts->connfd);
	return (void *)0;
}

int main(void)
{
	struct sockaddr_in servaddr, cliaddr;
	socklen_t cliaddr_len;
	int listenfd, connfd;
	int i = 0;
	pthread_t tid;
	struct s_info ts[256];

	//创建服务端socket
	listenfd = Socket(AF_INET, SOCK_STREAM, 0);

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(SERV_PORT);
	
	//绑定服务端的socket
	Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
	//设置监听socket，最大监听数为：20
	Listen(listenfd, 20);

	printf("Accepting connections ...\n");
	while (1) {
		cliaddr_len = sizeof(cliaddr);
		//等待客户端连接
		connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);
		ts[i].cliaddr = cliaddr;
		ts[i].connfd = connfd;
		/* 达到线程最大数时，pthread_create出错处理, 增加服务器稳定性 */
		pthread_create(&tid, NULL, do_work, (void*)&ts[i]);
		i++;
	}
	return 0;
}

2.2.2.2 Client端代码

/* client.c */

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "wrap.h"
#define MAXLINE 80
#define SERV_PORT 8888
int main(int argc, char *argv[])
{
	struct sockaddr_in servaddr;
	char buf[MAXLINE];
	int sockfd, n;
	
	//创建客户端中的socket，其为服务端在客户端中代表
	sockfd = Socket(AF_INET, SOCK_STREAM, 0);

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
	servaddr.sin_port = htons(SERV_PORT);
	
	//连接服务端
	Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
	//通过sockfd向服务端发送请求，并接收返回信息
	while (fgets(buf, MAXLINE, stdin) != NULL) {
		Write(sockfd, buf, strlen(buf));
		n = Read(sockfd, buf, MAXLINE);
		if (n == 0)
			printf("the other side has been closed.\n");
		else
			Write(STDOUT_FILENO, buf, n);
	}
	//通信结束后，关闭socket
	Close(sockfd);
	return 0;
}

2.3 I/O多路复用模型

2.3.1 I/O多路复用模型框架

  I/O 多路复用模型利用单一进程或线程为多客户端提供服务。I/O 多路复用模型中最具代表性的是使用 select() 函数。
select() 函数对处理多个 IO 事件的文件描述符的集合 (fd_set) 进行监控。文件描述符集中如果特定文件描述符发生 I/O 事件( 读、写、错误等)，文件描述符集中相应的文件描述符的位会发生变化。select() 函数感应到文件描述符位的变化后，返回等待状态，并执行相应文件描述符的读取及写人操作。select() 函数默认提示 I/O 事件的发生，但不会告知文件描述符中发生的是第几个 I/O 事件。因此需要执行循环，找到文件描述符集的第几个文件描述符位中发生了 I/O 事件。下图是 I/O 多路复用的概念。I/O 多路复用处理多客户端进程的服务请求，不生成新进程，其主旨思想是，不再由应用程序自己监视客户端连接，取而代之由内核替应用程序监视文件。
在这里插入图片描述
I/O多路复用模型的实现可以有三种方法：

  • select
  • poll
  • epoll

2.3.2 I/O多路复用模型代码实例

2.3.2.1 使用 select 实现的 Server 端代码

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

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

	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.c */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <ctype.h>
#include "wrap.h"

#define MAXLINE 80
#define SERV_PORT 6666

int main(int argc, char *argv[])
{
	int i, maxi, maxfd, listenfd, connfd, sockfd;
	int nready, client[FD_SETSIZE]; 	/* FD_SETSIZE 默认为 1024 */
	ssize_t n;
	fd_set rset, allset;				/* rset 读事件文件描述符集合 allset用来暂存 */
	char buf[MAXLINE];
	char str[INET_ADDRSTRLEN]; 			/* #define INET_ADDRSTRLEN 16 */
	socklen_t cliaddr_len;
	struct sockaddr_in cliaddr, servaddr;
	
	//创建服务端socket
	listenfd = Socket(AF_INET, SOCK_STREAM, 0);

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(SERV_PORT);
	//绑定服务端的socket
	Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
	//设置监听socket，最大监听数为：20
	Listen(listenfd, 20); 		/* 默认最大128 */

	maxfd = listenfd; 			/* 起初 listenfd 即为最大文件描述符 */
	maxi = -1;					/* 将来用作client[]的下标, 初始值指向0个元素之前下标位置 */

	for (i = 0; i < FD_SETSIZE; i++)
		client[i] = -1; 		/* 用-1初始化client[] */

	FD_ZERO(&allset);
	FD_SET(listenfd, &allset); /* 构造select监控文件描述符集 */

	for (;;) {
		rset = allset; 			/* 每次循环时都重新设置select监控信号集 */
		nready = select(maxfd+1, &rset, NULL, NULL, NULL);

		if (nready < 0)
			perr_exit("select error");

		// 当有新客户端连接时
		if (FD_ISSET(listenfd, &rset)) {		/* 说明有新的客户端链接请求 */
			cliaddr_len = sizeof(cliaddr);
			connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);	/* Accept 不会阻塞 */
			printf("received from %s at PORT %d\n",
					inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),
					ntohs(cliaddr.sin_port));
			for (i = 0; i < FD_SETSIZE; i++) {
				if (client[i] < 0) {	/* 找client[]中没有使用的位置 */
					client[i] = connfd; /* 保存accept返回的文件描述符到client[]里 */
					break;
				}
			}
			
			/* 达到select能监控的文件个数上限 1024 */
			if (i == FD_SETSIZE) {
				fputs("too many clients\n", stderr);
				exit(1);
			}

			FD_SET(connfd, &allset); 	/* 向监控文件描述符集合allset添加新的文件描述符connfd */
			if (connfd > maxfd)
				maxfd = connfd; 		/* select第一个参数需要 */
			if (i > maxi)
				maxi = i; 				/* 保证maxi存的总是client[]最后一个元素下标 */

			if (--nready == 0)
				continue; 				/* 如果没有更多的就绪文件描述符继续回到上面select阻塞监听,
											负责处理未处理完的就绪文件描述符 */
		}
		
		//检测哪个 client 有数据就绪了
		for (i = 0; i <= maxi; i++) {
			if ( (sockfd = client[i]) < 0)
				continue;
			if (FD_ISSET(sockfd, &rset)) {
				if ( (n = Read(sockfd, buf, MAXLINE)) == 0) {
					Close(sockfd);		/* 当client关闭链接时，服务器端也关闭对应链接 */
					FD_CLR(sockfd, &allset); /* 解除select监控此文件描述符 */
					client[i] = -1;
				} else {
					int j;
					for (j = 0; j < n; j++)
						buf[j] = toupper(buf[j]);
					Write(sockfd, buf, n);
				}
				if (--nready == 0)
					break;				/* 跳出for, 但还在while中 */
			}
		}
		
	}
	Close(listenfd);
	return 0;
}

2.3.2.2 使用 select 实现的 Client 端代码

/* client.c */

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "wrap.h"

#define MAXLINE 80
#define SERV_PORT 6666

int main(int argc, char *argv[])
{
	struct sockaddr_in servaddr;
	char buf[MAXLINE];
	int sockfd, n;

	//创建客户端中的socket，其为服务端在客户端中代表
	sockfd = Socket(AF_INET, SOCK_STREAM, 0);

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
	servaddr.sin_port = htons(SERV_PORT);
	
	//连接服务端
	Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

	//通过sockfd向服务端发送请求，并接收返回信息
	while (fgets(buf, MAXLINE, stdin) != NULL) {
		Write(sockfd, buf, strlen(buf));
		n = Read(sockfd, buf, MAXLINE);
		if (n == 0)
			printf("the other side has been closed.\n");
		else
			Write(STDOUT_FILENO, buf, n);
	}
	//通信结束后，关闭socket
	Close(sockfd);
	return 0;
}

2.3.2.3 使用 poll 实现的 Server 端代码

#include <poll.h>
	/**
		POLLIN			普通或带外优先数据可读，即POLLRDNORM | POLLRDBAND
		POLLRDNORM		数据可读
		POLLRDBAND		优先级带数据可读
		POLLPRI 		高优先级可读数据
		POLLOUT			普通或带外数据可写
		POLLWRNORM		数据可写
		POLLWRBAND		优先级带数据可写
		POLLERR 		发生错误
		POLLHUP 		发生挂起
		POLLNVAL 		描述字不是一个打开的文件

		nfds 			监控数组中有多少文件描述符需要被监控

		timeout 		毫秒级等待
						-1：阻塞等，#define INFTIM -1
				 		 0：立即返回，不阻塞进程
						>0：等待指定毫秒数，如当前系统时间精度不够毫秒，向上取值
	*/
	int poll(struct pollfd *fds, nfds_t nfds, int timeout);

	/**
		如果不再监控某个文件描述符时，可以把pollfd中，fd设置为-1，poll不再监控此pollfd，
		下次返回时，把revents设置为0。
	*/
	struct pollfd {
		int fd; /* 文件描述符 */
		short events; /* 监控的事件 */
		short revents; /* 监控事件中满足条件返回的事件 */
	};

/* server.c */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <poll.h>
#include <errno.h>
#include "wrap.h"

#define MAXLINE 80
#define SERV_PORT 6666
#define OPEN_MAX 1024

int main(int argc, char *argv[])
{
	int i, j, maxi, listenfd, connfd, sockfd;
	int nready;	//接收poll返回值, 记录满足监听事件的fd个数
	ssize_t n;
	char buf[MAXLINE], str[INET_ADDRSTRLEN];
	socklen_t clilen;
	struct pollfd client[OPEN_MAX];
	struct sockaddr_in cliaddr, servaddr;
	
	//创建服务端socket
	listenfd = Socket(AF_INET, SOCK_STREAM, 0);

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(SERV_PORT);

	//绑定服务端的socket
	Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
	//设置监听socket，最大监听数为：20
	Listen(listenfd, 20);

	client[0].fd = listenfd;						/* 要监听的第一个文件描述符 存入client[0] */
	client[0].events = POLLRDNORM; 					/* listenfd监听普通读事件 */

	for (i = 1; i < OPEN_MAX; i++)
		client[i].fd = -1; 							/* 用-1初始化client[]里剩下元素 */
	maxi = 0; 										/* client[]数组有效元素中最大元素下标 */

	for (;;) {
		nready = poll(client, maxi+1, -1); 			/* 阻塞监听是否有客户端链接请求 */

		// 有客户端链接请求
		if (client[0].revents & POLLRDNORM) {		/* listenfd有读事件就绪 */
			clilen = sizeof(cliaddr);
			connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &clilen);	/* 接收客户端请求 Accept 不会阻塞 */
			printf("received from %s at PORT %d\n",
					inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),
					ntohs(cliaddr.sin_port));
			for (i = 1; i < OPEN_MAX; i++) {
				if (client[i].fd < 0) {
					client[i].fd = connfd; 	/* 找到client[]中空闲的位置，存放accept返回的connfd */
					break;
				}
			}

			if (i == OPEN_MAX)				/* 达到了最大客户端数 */
				perr_exit("too many clients");

			client[i].events = POLLRDNORM; 		/* 设置刚刚返回的connfd，监控读事件 */
			if (i > maxi)
				maxi = i; 						/* 更新client[]中最大元素下标 */
			if (--nready <= 0)
				continue; 						/* 没有更多就绪事件时,继续回到poll阻塞 */
		}
		
		// 检测client[]
		for (i = 1; i <= maxi; i++) {			/* 前面的if没满足,说明没有listenfd满足. 检测client[] 看是那个connfd就绪 */
			if ((sockfd = client[i].fd) < 0)
				continue;
			if (client[i].revents & (POLLRDNORM | POLLERR)) {
				if ((n = Read(sockfd, buf, MAXLINE)) < 0) {
					if (errno == ECONNRESET) { /* 当收到 RST标志时 */
						/* connection reset by client */
						printf("client[%d] aborted connection\n", i);
						Close(sockfd);
						client[i].fd = -1;		/* poll中不监控该文件描述符,直接置为-1即可,不用像select中那样移除 */
					} else {
						perr_exit("read error");
					}
				} else if (n == 0) {			/* 说明客户端先关闭链接 */
					/* connection closed by client */
					printf("client[%d] closed connection\n", i);
					Close(sockfd);
					client[i].fd = -1;
				} else {
					for (j = 0; j < n; j++)
						{buf[j] = toupper(buf[j]);}
					Writen(sockfd, buf, n);
				}
				if (--nready <= 0)
					break; 				/* no more readable descriptors */
			}
		}
		
	}
	return 0;
}

2.3.2.4 使用 poll 实现的 Client 端代码

/* client.c */

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "wrap.h"

#define MAXLINE 80
#define SERV_PORT 6666

int main(int argc, char *argv[])
{
	struct sockaddr_in servaddr;
	char buf[MAXLINE];
	int sockfd, n;

	//创建客户端中的socket，其为服务端在客户端中代表
	sockfd = Socket(AF_INET, SOCK_STREAM, 0);

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
	servaddr.sin_port = htons(SERV_PORT);
	
	//连接服务端
	Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

	//通过sockfd向服务端发送请求，并接收返回信息
	while (fgets(buf, MAXLINE, stdin) != NULL) {
		Write(sockfd, buf, strlen(buf));
		n = Read(sockfd, buf, MAXLINE);
		if (n == 0)
			printf("the other side has been closed.\n");
		else
			Write(STDOUT_FILENO, buf, n);
	}
	//通信结束后，关闭socket
	Close(sockfd);
	return 0;
}

2.3.2.5 使用 epoll 实现的 Server 端代码

  epoll 是Linux下多路复用IO接口select/poll的增强版本，它能显著提高程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率：

  • 因为它会复用文件描述符集合来传递结果而不用迫使开发者每次等待事件之前都必须重新准备要被侦听的文件描述符集合
  • 另一点原因是获取事件的时候，它无须遍历整个被侦听的描述符集，只要遍历那些被内核I/O事件异步唤醒而加入Ready队列的描述符集合就行了

  目前epoll是linux大规模并发网络程序中的热门首选模型。除了提供 select/poll 那种I/O事件的电平触发（Level Triggered）外，还提供了边沿触发（Edge Triggered），这就使得用户空间程序有可能缓存I/O状态，减少 epoll_wait/epoll_pwait的调用，提高应用程序效率。

epoll的一些基础API：

  1. 创建一个epoll句柄，参数size用来告诉内核监听的文件描述符的个数，跟内存大小有关。
    #include <sys/epoll.h>
int epoll_create(int size)		//size：监听数目
  2. 控制某个epoll监控的文件描述符上的事件：注册、修改、删除。
    #include <sys/epoll.h>

	/**
		epfd：	为epoll_creat的句柄
		op：	表示动作，用3个宏来表示：
				EPOLL_CTL_ADD (注册新的fd到epfd)，
				EPOLL_CTL_MOD (修改已经注册的fd的监听事件)，
				EPOLL_CTL_DEL (从epfd删除一个fd)；
		event：	告诉内核需要监听的事件
	*/
	int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)

	/**
		EPOLLIN ：	表示对应的文件描述符可以读（包括对端SOCKET正常关闭）
		EPOLLOUT：	表示对应的文件描述符可以写
		EPOLLPRI：	表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）
		EPOLLERR：	表示对应的文件描述符发生错误
		EPOLLHUP：	表示对应的文件描述符被挂断；
		EPOLLET： 	将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)而言的
		EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里
	*/
	struct epoll_event {
		__uint32_t events; /* Epoll events */
		epoll_data_t data; /* User data variable */
	};

	typedef union epoll_data {
		void *ptr;
		int fd;
		uint32_t u32;
		uint64_t u64;
	} epoll_data_t;
  3. 等待所监控文件描述符上有事件的产生，类似于select()调用。
    #include <sys/epoll.h>

/**
	events：	用来存内核得到事件的集合，
	maxevents：	告之内核这个events有多大，这个maxevents的值不能大于创建epoll_create()时的size，
	timeout：	是超时时间
				-1：	阻塞
				 0：	立即返回，非阻塞
				>0：	指定毫秒
	返回值：		成功返回有多少文件描述符就绪，时间到时返回0，出错返回-1
*/
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout)

/*server.c*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/epoll.h>
#include <errno.h>
#include <ctype.h>
#include "wrap.h"

#define MAXLINE 80
#define SERV_PORT 6666
#define OPEN_MAX 1024

int main(int argc, char *argv[])
{
	int i, j, maxi, listenfd, connfd, sockfd;
	int nready, efd, res;
	ssize_t n;
	char buf[MAXLINE], str[INET_ADDRSTRLEN];
	socklen_t clilen;
	int client[OPEN_MAX];
	struct sockaddr_in cliaddr, servaddr;
	struct epoll_event tep, ep[OPEN_MAX];
	
	//创建服务端socket
	listenfd = Socket(AF_INET, SOCK_STREAM, 0);

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(SERV_PORT);

	//绑定服务端的socket
	Bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr));
	
	//设置监听socket，最大监听数为：20
	Listen(listenfd, 20);

	for (i = 0; i < OPEN_MAX; i++)
		client[i] = -1;
	maxi = -1;

	efd = epoll_create(OPEN_MAX);	//创建epoll模型, efd指向红黑树根节点
	if (efd == -1)
		perr_exit("epoll_create");

	tep.events = EPOLLIN; tep.data.fd = listenfd;	//指定lfd的监听时间为"读"

	res = epoll_ctl(efd, EPOLL_CTL_ADD, listenfd, &tep);	//将lfd及对应的结构体设置到树上,efd可找到该树
	if (res == -1)
		perr_exit("epoll_ctl");

	while (1) {
		nready = epoll_wait(efd, ep, OPEN_MAX, -1); /*epoll为server阻塞监听事件, ep为struct epoll_event类型数组, OPEN_MAX为数组容量, -1表永久阻塞*/
		if (nready == -1)
			perr_exit("epoll_wait");

		for (i = 0; i < nready; i++) {
			if (!(ep[i].events & EPOLLIN))	//如果不是"读"事件, 继续循环
				continue;
			if (ep[i].data.fd == listenfd) {//判断满足事件的fd是不是lfd      
				clilen = sizeof(cliaddr);
				connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &clilen);//接受链接
				printf("received from %s at PORT %d\n", 
						inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)), 
						ntohs(cliaddr.sin_port));
				for (j = 0; j < OPEN_MAX; j++) {
					if (client[j] < 0) {
						client[j] = connfd; /* save descriptor */
						break;
					}
				}

				if (j == OPEN_MAX)
					perr_exit("too many clients");
				if (j > maxi)
					maxi = j; 		/* max index in client[] array */

				tep.events = EPOLLIN; 
				tep.data.fd = connfd;
				res = epoll_ctl(efd, EPOLL_CTL_ADD, connfd, &tep);
				if (res == -1)
					perr_exit("epoll_ctl");
			} else {//不是lfd, 
				sockfd = ep[i].data.fd;
				n = Read(sockfd, buf, MAXLINE);
				if (n == 0) {//读到0,说明客户端关闭链接
					for (j = 0; j <= maxi; j++) {
						if (client[j] == sockfd) {
							client[j] = -1;
							break;
						}
					}
					res = epoll_ctl(efd, EPOLL_CTL_DEL, sockfd, NULL);//将该文件描述符从红黑树摘除
					if (res == -1)
						perr_exit("epoll_ctl");

					Close(sockfd);//关闭与该客户端的链接
					printf("client[%d] closed connection\n", j);
				} else {//实际读到了字节数
					for (j = 0; j < n; j++)
						buf[j] = toupper(buf[j]);//转大写,写回给客户端
					Writen(sockfd, buf, n);
				}
			}
		}
	}
	Close(listenfd);
	Close(efd);
	return 0;
}

2.3.2.6 使用 epoll 实现的 Client 端代码

/* client.c */

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "wrap.h"

#define MAXLINE 80
#define SERV_PORT 6666

int main(int argc, char *argv[])
{
	struct sockaddr_in servaddr;
	char buf[MAXLINE];
	int sockfd, n;

	//创建客户端中的socket，其为服务端在客户端中代表
	sockfd = Socket(AF_INET, SOCK_STREAM, 0);

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
	servaddr.sin_port = htons(SERV_PORT);
	
	//连接服务端
	Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

	//通过sockfd向服务端发送请求，并接收返回信息
	while (fgets(buf, MAXLINE, stdin) != NULL) {
		Write(sockfd, buf, strlen(buf));
		n = Read(sockfd, buf, MAXLINE);
		if (n == 0)
			printf("the other side has been closed.\n");
		else
			Write(STDOUT_FILENO, buf, n);
	}
	//通信结束后，关闭socket
	Close(sockfd);
	return 0;
}

2.4 三种模型优缺点对比

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/564789.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

C++条件变量condition_variable

C++条件变量condition_variable

一、问题 假设没有条件变量&#xff0c;对于一个生产者消费者问题&#xff0c;消费线程在得知队列中没有产品时&#xff0c;将阻塞自己。生产者线程可以给队列中放入产品&#xff0c;但是没有办法激活消费者线程&#xff0c;而消费者线程处于阻塞状态也没有办法自己激活自己。…
阅读更多...
RocketMQ 领域模型概述

RocketMQ 领域模型概述

本文为您介绍 Apache RocketMQ 的领域模型。 Apache RocketMQ 是一款典型的分布式架构下的中间件产品&#xff0c;使用异步通信方式和发布订阅的消息传输模型。通信方式和传输模型的具体说明&#xff0c;请参见下文通信方式介绍和消息传输模型介绍。 Apache RocketMQ 产品具备…
阅读更多...
IOS开发指南之自定义TableViewCell使用

IOS开发指南之自定义TableViewCell使用

演示效果: 1.自定义TableViewCell创建 File->new->File... 在iOS模板中选择Empty来创建一个空的XIB文件,然后点击下一步 输入XIB文件名Cell,然后点击Create创建 创建XIB文件成功后如下: 同时按钮Shift+command+L弹出库,然后输入 table筛选,选择Table View Cell 拖到下…
阅读更多...
一文通透spring的初始化

一文通透spring的初始化

简述 今天重点分析ApplicationContext初始化时做的事情&#xff0c;我们都只到spring是个IOC和AOP容器&#xff0c;那再我们new一个ApplicationContext&#xff0c;spring内部都做了什么&#xff1f;怎么实现的IOC和AOP&#xff1f; 比如说下面这段代码 Configuration Compon…
阅读更多...
计组 第二章 数据的表示与运算 2.1 数制与编码 知识点整理

计组 第二章 数据的表示与运算 2.1 数制与编码 知识点整理

2.1 数制与编码 二进制转八进制&#xff1a;3位一组&#xff0c;高位补0 二进制转十六进制&#xff1a;4位一组&#xff0c;高位补0 任意进制转十进制&#xff08;按权展开法&#xff09;&#xff1a;数码与权值相乘&#xff0c;再相加 十进制转化为任意进制数&#xff08;基…
阅读更多...
全面接入：ChatGPT杀进10个商业应用，让AI替你打工

全面接入：ChatGPT杀进10个商业应用，让AI替你打工

ChatGPT狂飙160天&#xff0c;世界已经不是两个月前的样子。 新建了一个网站 https://ai.weoknow.com/ 每天给大家更新可用的国内可用chatGPT资源 ChatGPT API已开放60多天。世界已经不是两个月前的样子了。 微软联合创始人比尔盖茨&#xff08;BillGates&#xff09;将GPT称…
阅读更多...
一、预约挂号详情

一、预约挂号详情

文章目录 一、预约挂号详情1、需求分析 2、api接口2.1 添加service接口2.2 添加service接口实现2.2.1 在ScheduleServiceImpl类实现接口2.2.2 在获取科室信息 2.3 添加controller方法 3、前端3.1封装api请求3.2 页面展示 二、预约确认1、api接口1.1 添加service接口1.2 添加con…
阅读更多...
FastRcnn理论合集

FastRcnn理论合集

FastRcnn理论合集 Rcnn 论文原著 Rich feature hierarchies for accurate object detection and semantic segmentation R-CNN可以说是利用深度学习进行目标检测的开山之作。作者Ross Girshick多次在PASCAL VOC的目标检测竞赛中折桂&#xff0c;曾在2010年带领团队获得终身成就…
阅读更多...
【P29】JMeter IF 控制器（If Controller）

【P29】JMeter IF 控制器（If Controller）

文章目录 一、IF 控制器&#xff08;If Controller&#xff09;参数说明二、测试计划设计2.1、groovy 写法2.2、javaScript 写法2.3、jexl3 写法 一、IF 控制器&#xff08;If Controller&#xff09;参数说明 可以控制其下面的子/后代元素是否执行&#xff1b;如果为 true 则…
阅读更多...
CSDN问答机器人

CSDN问答机器人

文章目录 前言一、背景二、总体流程三、构建知识库四、粗排五、精排六、Prompt总结相关博客 前言 先看结果: 已经连续很多周获得了第二名(万年老二), 上周终于拿了一回第一, 希望继续保持. &#x1f601; 这是今天的榜单, 采纳的数量相对较少, 之前基本上维持在100 重点说明…
阅读更多...
数字韧性助力金融科技行稳致远 同创永益亮相2023双态IT武汉樱花论坛

数字韧性助力金融科技行稳致远 同创永益亮相2023双态IT武汉樱花论坛

2023年4月7日&#xff0c;由ITSS数据中心运营管理组DCMG指导&#xff0c;双态IT论坛主办的以“分布式架构和云原生时代的运维软件进化”为主题的“双态IT武汉樱花论坛”在武汉成功举办&#xff0c;共有来自银行、保险、证券等行业用户及企业代表近百人参会。 云原生时代下&am…
阅读更多...
【Linux】-yum的使用

【Linux】-yum的使用

&#x1f496;作者&#xff1a;小树苗渴望变成参天大树 ❤️‍&#x1fa79;作者宣言&#xff1a;认真写好每一篇博客 &#x1f4a8;作者gitee:gitee &#x1f49e;作者专栏&#xff1a;C语言,数据结构初阶,Linux,C 如 果 你 喜 欢 作 者 的 文 章 &#xff0c;就 给 作 者 点…
阅读更多...
某生存游戏玩家属性值分析

某生存游戏玩家属性值分析

0x01 背景 这是一款丧尸生存的多人沙盒类游戏&#xff0c;角色在废墟之城内不断的搜刮&#xff0c;强化自己的装备和建造设施来抵御丧尸的无休止攻击&#xff0c;记住&#xff0c;这是一款团队合作游戏&#xff0c;你面对的丧尸随时可能夺走你的性命&#xff01; 0x02 玩家结…
阅读更多...
【C++ Primer Plus】基础知识

【C++ Primer Plus】基础知识

C站的小伙伴们&#xff0c;大家好呀&#xff01;我最近开始阅读学习《C Primer Plus》这本书&#xff0c;在这里和大家一起分享。 下面是本书的第二章《开始学习C》 开始学习C 进入Cmain&#xff08;&#xff09;函数C注释C预处理器和iostream文件头文件名名称空间使用count进行…
阅读更多...
【Linux专区】 Linux is not unix | Linux发展史 | Linux应用现状

【Linux专区】 Linux is not unix | Linux发展史 | Linux应用现状

&#x1f49e;&#x1f49e;欢迎来到 Claffic 的博客&#x1f49e;&#x1f49e; &#x1f449; 专栏&#xff1a;《Linux专区》&#x1f448; 前言&#xff1a; 上次提前带大家搭建了Linux的环境&#xff0c;其实之前应该还有一步的&#xff0c;就是向大家介绍Linux发展史&…
阅读更多...
HNU-电路与电子学-小班3

HNU-电路与电子学-小班3

第三次讨论 1 、直接用晶体管而不是逻辑门实现异或门&#xff0c;并解释这个电路是如何工作的。 &#xff08;6个 MOS 管构成&#xff09; 2 、通信双方约定采用 7 位海明码进行数据传输。请为发送方设计海明码校验位 生成电路&#xff0c;采用功能块和逻辑门为接收方设计海…
阅读更多...
SCMA基本原理介绍

SCMA基本原理介绍

SCMA: Sparse Code Multiple Access SCMA基本原理 我们考虑一个同步&#xff08;synchronous&#xff09;的SCMA系统&#xff0c; 含1个基站&#xff08;Base Station, BS&#xff09;&#xff1b; J J J个用户&#xff08;so called layers&#xff09;&#xff1b;K个OFDM…
阅读更多...
算法练习-2：送外卖

算法练习-2：送外卖

n 个小区排成一列&#xff0c;编号为从 0 到 n-1 。一开始&#xff0c;美团外卖员在第0号小区&#xff0c;目标为位于第 n-1 个小区的配送站。 给定两个整数数列 a[0]~a[n-1] 和 b[0]~b[n-1] &#xff0c;在每个小区 i 里你有两种选择&#xff1a; 1) 选择a&#xff1a;向前 a[…
阅读更多...
shiro环境搭建

shiro环境搭建

源码部署 这种方法相对复杂&#xff0c;如果不需要分析源码直接用docker就行 前置条件&#xff1a;Maven Ideal Tomcat 下载方式1&#xff1a;https://codeload.github.com/apache/shiro/zip/shiro-root-1.2.4&#xff0c;然后将文件夹导入ideal下载方式2&#xff1a;将shiro…
阅读更多...
装饰者模式-java实现

装饰者模式-java实现

的简介 装饰模式又称为“包装(Wrapper)模式”&#xff0c;以对客户端透明的方式扩展对象的功能&#xff0c;是继承关系的一个替代方案。动态地给对象添加一些额外地职责&#xff0c;就增加功能而言&#xff0c;装饰模式比生成子类更加灵活。 一般来说&#xff0c;一些特殊场景…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023