TCP网络编程模型从入门到实战中等篇,单服务器多个用户的简单并发版本, 从多进程 到多线程 到 线程池 版本服务器实现...直到最终解决面试经典C10k高并发服务器设计

目录

一. 继续解决上一篇留下的疑惑

二. 多进程模型实现服务器支持多用户连接

三. 多线程模型实现服务器支持多用户连接

四. 线程池实现服务器支持多用户连接

五. 总结本章


一. 继续解决上一篇留下的疑惑

  • 如果上一篇没看过的, 附上链接一份, 看完可以帮助后序学习https://blog.csdn.net/weixin_53695360/article/details/122754482?spm=1001.2014.3001.5502
  • 问题抛出 :     为何在一个时间段中, 不可以支持多个用户的同时访问服务器,  只能够支持一个用户访问服务器结束, 断开连接下一个用户才可以进行连接?
  • 原因 :  因为我们前文中的TCP socket  是最简单的, 基本的一对一的通信, 是同步阻塞的方式, 也就是说 当服务器 还没有处理完一个客户的网络 I/O的时候, 或者 读写操作发生阻塞时候 其他客户是没有办法与服务端进行连接操作的
  • 官方解释一下这个同步阻塞原因 : 就是主线程, 建立连接的线程被阻塞处理 网络 IO 了(占用,不空, 处理完这个IO之前没法建立新的连接) 
  • 其实简单的解释一下 同步阻塞含义 :  其他客户端 需要和 正在被服务的客户端一起同步阻塞等待服务器服务结束 哪一个正在服务的客户端 才能够建立新的连接
  • 解决方法综述:    多进程     多线程      线程池       IO 多路复用技术   (本文介绍前三种)

二. 多进程模型实现服务器支持多用户连接

首先是理论支撑

  • 服务器端主进程 (父进程) 仅仅只是负责监听客户端的连接, 每一次accept接受一次连接之后, 我们就 fork 出来一个子进程来处理这个连接所需的服务....
  • 简单回顾fork() :  我不喜欢理解成创建一个子进程, 我喜欢理解成复制一个进程出来, 这个进程中和原来的进程相比, 需要处理的后序代码逻辑是一摸一样的, 内存地址空间, 程序计数器等等都是完成摹刻出来的. 仅有的区别, 就是 pid 不同, 还有 如何区分主进程逻辑还是子进程逻辑, 通过fork 返回值来看, 返回值 为 0 代表是子进程处理逻辑,返回值 > 0, 也就是返回子进程的pid 代表父进程处理逻辑
  • 父子分工 :父进程直接关闭 自己所属的一份 connfd socket文件描述符, 然后只负责监听, 同时负责回收子进程资源, 防止僵尸, 此处为避免阻塞收尸, 可以采取轮询式, 或者我一般直接设置信号处理SIGCHLD 信号. 然后子进程来实现网络IO传输和服务操作....
  • signal(SIGCHLD, SIG_IGN);        //避免子进程僵尸, 设置SIGCHLD信号为SIG_IGN 自动收尸, 不会僵尸..... 丢给系统去处理..
  • 主题fork 多进程实现并发服务逻辑伪代码:
        pid = fork();
    	if (pid < 0) {
    		ERR_EXIT("fork");
    	}
    	if (pid) {
    		close(connfd);						//父进程只进行监听
    	} else {
    		close(listenfd);					//子进程不需要监听
            .....                               //服务逻辑代码
    	}

还是上文连接所实现的过程, 服务端将客户端发来的字符转大写写回.

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define SERVE_PORT 12345
#define ERR_EXIT(m) \
	do { perror(m); exit(EXIT_FAILURE); } while (0)
typedef struct sockaddr SA;
int listenfd;								//设置全局监听套接字, 方便关闭
void handle(int signo) {
	fprintf(stdout, "ByeBye!\n");
	close(listenfd);
	exit(EXIT_SUCCESS);
}

int main() {
	signal(SIGCHLD, SIG_IGN);
	signal(SIGINT, handle);
	int listenfd, connfd, pid;
	struct sockaddr_in serveAdd, clientAdd;
	socklen_t clientAdd_len;
	char ipbuff[256];
	//创建套接字
	if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
		ERR_EXIT("socket");	//协议家族 服务类型(套接字类型), 协议弃用(0)
	}
	//确定服务端地址簇
	bzero(&serveAdd, sizeof(serveAdd));					//清0
	serveAdd.sin_family = AF_INET;
	serveAdd.sin_port = htons(SERVE_PORT);
	serveAdd.sin_addr.s_addr = htonl(INADDR_ANY);		//注意转网络字节序
	//bind 端口 地址信息
	if (bind(listenfd, (SA*)&serveAdd, sizeof(serveAdd)) == -1) {
		ERR_EXIT("bind");
	}
	//开始监听..
	if (listen(listenfd, 3) == -1) {
		ERR_EXIT("listen");
	}
	printf("Accepting connections..\n");
	//循环不断的接收客户的连接请求进行服务
	while (1) {
		clientAdd_len = sizeof(clientAdd);
		if ((connfd = accept(listenfd, (SA*)&clientAdd, &clientAdd_len)) == -1) {
			ERR_EXIT("accept");
		}
		printf("recieve connection from ip is %s and port is %d\n",
			inet_ntop(AF_INET, &clientAdd.sin_addr, ipbuff, sizeof(ipbuff)), 
			ntohs(clientAdd.sin_port));
		pid = fork();
		if (pid < 0) {
			ERR_EXIT("fork");
		}
		if (pid) {
			close(connfd);							//父进程只进行监听
		} else {
			//服务
			close(listenfd);						//子进程不需要监听
			while (1) {
				char buff[1024] = {0};
				int i;
				int n = read(connfd, buff, sizeof(buff));	//读数据
				if (n == -1) {
					ERR_EXIT("read");
				} 
				if (n == 0) {						//说明客户端主动断开连接
					break;
				}
				//处理数据, 简单的小写字符转大写
				for (i = 0; i < n; ++i) {
					buff[i] = toupper(buff[i]);
				}
				//写回
				write(connfd, buff, n);
			}
    		fprintf(stdout, "ip %s and port is %d interrupt connfd\n",
        		ipbuff, ntohs(clientAdd.sin_port));
			close(connfd);
		}													
	}						
	return 0;
}
  • 使用多进程来应付多客户端的弊端  : 进程的创建需要消耗大量的系统资源,   又特别是内存资源这些都是有限的, 所以使用多进程的方式, 处理 <= 100 这种 少量客户端还行, 当C10k问题来临是, 根本无能为力, 毕竟进程的产生, 进程间切换的包袱是很重的...... 

三. 多线程模型实现服务器支持多用户连接

  •    竟然 进程间切换, 以及进程创建 所耗系统资源太大了, 那我们就使用轻量级进程, 多个线程共用一个进程地址空间, 来减轻负重  -----  多线程模型

首先还是理论支撑      

  • 多线程共享所在进程数据 :  文件描述符列表,进程空间,代码,全局数据,堆,共享库
  • 线程是运行在进程中的一个 "执行流' 单个进程中可以运行多个线程, 同一进程里面多个线程共享进程的部分资源,          这样线程间切换的时候仅仅只是切换线程私有数据, 寄存器等不共享数据, 相比进程间切换开销大大减少....
  • 线程创建函数的图解分析 :TCP网络编程模型从入门到实战中等篇,单服务器多个用户的简单并发版本, 从多进程 到多线程 到 线程池 版本服务器实现...直到最终解决面试经典C10k高并发服务器设计_第1张图片 
  • 然后是线程回收资源的设置, 此处, 我们不设置主线程等待回收, 介绍一个pthread_detach函数TCP网络编程模型从入门到实战中等篇,单服务器多个用户的简单并发版本, 从多进程 到多线程 到 线程池 版本服务器实现...直到最终解决面试经典C10k高并发服务器设计_第2张图片
  •  过程描述  (线程功能分析) :   每建立一个新的  connect  自然我们就  获取到一个新的connfd, 此时, 我们   就创建一个子线程, 且传入connfd, 子线程的功能, 就是两台主机网络通信的整个服务器的处理逻辑流程 (简单总结, 产生新的客户连接就创建新的子进程服务)....
  • 主体线程部分代码逻辑:
    	//线程逻辑代码:
        void* Routine(void* arg) {
            pthread_detach(pthread_self());
            int connfd = (int)arg;
            //网络通信服务端服务逻辑。。。
            return (void*)0;
        }
        //循环不断的接收客户的连接请求进行服务
    	while (1) {
    		clientAdd_len = sizeof(clientAdd);
    		if ((connfd = accept(listenfd, (SA*)&clientAdd, &clientAdd_len)) == -1) {
    			ERR_EXIT("accept");
    		}
    		printf("recieve connection from ip is %s and port is %d\n",
    			inet_ntop(AF_INET, &clientAdd.sin_addr, ipbuff, sizeof(ipbuff)), 
    		ntohs(clientAdd.sin_port));
    		//创建一个子线程, 来一个新的连接就创建一个
    		pthread_create(&tid, NULL, Routine, (void*)connfd);			
    	}	
           ​​​​​​
  • 整个服务端代码实现
    [tangyujie@VM-4-9-centos Serve]$ cat server.c
    #include 
    #include 
    #include 
    #include 
    #include 
    #include 
    #include 
    #include 
    #include 
    #include 
    
    #define SERVE_PORT 12345
    #define ERR_EXIT(m) \
    	do { perror(m); exit(EXIT_FAILURE); } while (0)
    typedef struct sockaddr SA;
    int listenfd;								//设置全局监听套接字, 方便关闭
    void handle(int signo) {
    	fprintf(stdout, "ByeBye!\n");
    	close(listenfd);
    	exit(EXIT_SUCCESS);
    }
    
    void* Routine(void* arg) {
    	pthread_detach(pthread_self());		//线程结束自动回收资源
    	int connfd = (int)arg;				//先将参数强转回去
    	//服务
    	while (1) {
    		char buff[1024] = {0};
    		int i;
    		int n = read(connfd, buff, sizeof(buff));//读数据
    		if (n == -1) {
    			ERR_EXIT("read");
    		} 
    		if (n == 0) {					//说明客户端断开连接了
    			break;
    		}
    		//处理数据, 简单的小写字符转大写
    		for (i = 0; i < n; ++i) {
    			buff[i] = toupper(buff[i]);
    		}
    		write(connfd, buff, n);		//写回
    	}
      fprintf(stdout, "interrupt connfd end\n");
    	close(connfd);					//服务结束断开连接	
    	return (void*)0;
    } 
    
    int main() {
    	signal(SIGCHLD, SIG_IGN);
    	signal(SIGINT, handle);
    	int listenfd, connfd;
      pthread_t tid;
    	struct sockaddr_in serveAdd, clientAdd;
    	socklen_t clientAdd_len;
    	char ipbuff[256];
    	//创建套接字
    	if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
    		ERR_EXIT("socket");	//协议家族 服务类型(套接字类型), 协议弃用(0)
    	}
    	//确定服务端地址簇
    	bzero(&serveAdd, sizeof(serveAdd));					//清0
    	serveAdd.sin_family = AF_INET;
    	serveAdd.sin_port = htons(SERVE_PORT);
    	serveAdd.sin_addr.s_addr = htonl(INADDR_ANY);		//注意转网络字节序
    	//bind 端口 地址信息
    	if (bind(listenfd, (SA*)&serveAdd, sizeof(serveAdd)) == -1) {
    		ERR_EXIT("bind");
    	}
    	//开始监听..
    	if (listen(listenfd, 3) == -1) {
    		ERR_EXIT("listen");
    	}
    	printf("Accepting connections..\n");
    	//循环不断的接收客户的连接请求进行服务
    	while (1) {
    		clientAdd_len = sizeof(clientAdd);
    		if ((connfd = accept(listenfd, (SA*)&clientAdd, &clientAdd_len)) == -1) {
    			ERR_EXIT("accept");
    		}
    		printf("recieve connection from ip is %s and port is %d\n",
    			inet_ntop(AF_INET, &clientAdd.sin_addr, ipbuff, sizeof(ipbuff)), 
    		ntohs(clientAdd.sin_port));
    		//创建一个子线程, 来一个新的连接就创建一个
    		pthread_create(&tid, NULL, Routine, (void*)connfd);			
    	}																	
    	return 0;
    }
    
        ​​​​​​
  • 多线程模型  ---  相较多进程模型 缺失 减少了资源消耗, 但是...
  • 每来一个连接就创建一个线程, 线程运行结束之后操作系统还要销毁线程, 这个平凡的创建销毁线程的系统资源销毁(开销)  也是压力相当大的  此时应该可以支持  《= 1000 Client。 所以可以使用     (   线程池避免线程的频繁创建销毁  )

四. 线程池实现服务器支持多用户连接

线程池理论支撑   :附上连接一份, 学完应该足以支撑, 上一份代码是 C++的, 但是所用逻辑理论等是相通的.https://blog.csdn.net/weixin_53695360/article/details/122745816?spm=1001.2014.3001.5502

  • 过程描述, 在整个主线程最开始, 就可以开启,     (提前开启消费者工作线程等待任务来临)   我们的所有    工作线程 (饥饿的消费者, 等待客户端任务来临进行服务)    然后是线程逻辑,  我们在Routine 线程中 循环不断的接收 task_queue任务队列中的任务进行服务......   pop 任务  进行服务...   (因为线程池中是多线程, 任务队列中的任务就是临界资源)  所以为了整个过程的有序进行, 我们使用  锁 保护临界资源, 条件变量, 避免CPU的无端浪费....   
  • 上述语言看不明白, 说明线程池基础却有缺失, 可能需要阅读上文链接,或进一步查询资料

函数刨析

TCP网络编程模型从入门到实战中等篇,单服务器多个用户的简单并发版本, 从多进程 到多线程 到 线程池 版本服务器实现...直到最终解决面试经典C10k高并发服务器设计_第3张图片

  • 然后废话不多说, 上代码, 还是服务端代码
    [tangyujie@VM-4-9-centos Serve]$ cat server.c
    #include 
    #include 
    #include 
    #include 
    #include 
    #include 
    #include 
    #include 
    #include 
    #include 
    
    #define SERVE_PORT 12345
    #define ERR_EXIT(m) \
    	do { perror(m); exit(EXIT_FAILURE); } while (0)
    typedef struct sockaddr SA;
    int listenfd;								//设置全局监听套接字, 方便关闭
    
    //设置任务结构体.....
    typedef struct Task {
    	int connfd;								//任务需要晓得哈是哪个做
    	struct Task* next;
    } Task;
    
    typedef struct TaskQueue {
    	Task* front;
    	Task* tail;
    	pthread_mutex_t lock;
    	pthread_cond_t cond;
    } TaskQueue;
    
    TaskQueue* tp;
    
    void ClearTask(Task* head) {
    	Task* p = head, *q;
    	while (p) {
    		q = p->next;
    		free(p);
    		p = q;
    	}
    }
    
    void DestroyTaskQueue(TaskQueue* tp) {
    	ClearTask(tp->front);
    	pthread_mutex_destroy(&tp->lock);
    	pthread_cond_destroy(&tp->cond);
    }
    void handle(int signo) {
    	fprintf(stdout, "ByeBye!\n");
      DestroyTaskQueue(tp);
    	close(listenfd);
    	exit(EXIT_SUCCESS);
    }
    
    TaskQueue* InitTaskQueue() {
    	TaskQueue* tp = (TaskQueue*)malloc(sizeof(TaskQueue));
    	tp->front = tp->tail = NULL;
    	pthread_mutex_init(&tp->lock, NULL);
    	pthread_cond_init(&tp->cond, NULL);
    	return tp;
    }
    
    void Lock(TaskQueue* tp) {
    	pthread_mutex_lock(&tp->lock);
    }
    
    void Unlock(TaskQueue* tp) {
    	pthread_mutex_unlock(&tp->lock);
    }
    
    void WakeUp(TaskQueue* tp) {
    	pthread_cond_signal(&tp->cond);
    }
    
    void Wait(TaskQueue* tp) {
    	pthread_cond_wait(&tp->cond, &tp->lock);
    }
    
    Task* GetNewTask(int connfd) {
    	Task* newTask = (Task*)malloc(sizeof(Task));
    	newTask->connfd = connfd;
    	newTask->next = NULL;
    	return newTask;
    }
    
    int IsEmpty(TaskQueue* tp) {
    	return tp->front == NULL;
    }
    
    void Push(TaskQueue* tp, Task* task) {
    	Lock(tp);				//临界资源操作需要原子操作, 锁之间
    	if (IsEmpty(tp)) {
    		tp->front = task;
    		tp->tail = task;
        WakeUp(tp);     //唤醒通知有任务了      
    		Unlock(tp);		
    		return ;
    	} 
    	tp->tail->next = task;
    	tp->tail = task;
      WakeUp(tp);     //唤醒通知有任务了      
    	Unlock(tp);
    }
    
    Task* Pop(TaskQueue* tp) {
    	Lock(tp);
    	Task* poptask;
    	while (IsEmpty(tp)) {	//没有任务, 就一直等待生产
    		Wait(tp);			//循环是为了避免伪唤醒. 唤醒多个线程
    	}						    //但是有些线程 还要继续Wait, 所以循环
    	poptask = tp->front;
    	tp->front = tp->front->next;
    	if (tp->front == NULL) tp->tail = NULL;
    	Unlock(tp);   
    	return poptask;
    }
    
    
    void* Routine(void* arg) {
    	TaskQueue* tp = (TaskQueue*)arg;
      while (1) {                       //不断的尝试Pop获取任务进行处理
    	  int connfd = Pop(tp)->connfd;		//Pop任务后获取connfd
    	  //服务
    	  while (1) {
    		  char buff[1024] = {0};
    		  int i;
    		  int n = read(connfd, buff, sizeof(buff));//读数据
    		  if (n == -1) {
    			  ERR_EXIT("read");
    		  } 
    		  if (n == 0) {					//说明客户端断开连接了
    			  break;
    		  }
    		  //处理数据, 简单的小写字符转大写
    		  for (i = 0; i < n; ++i) {
    			  buff[i] = toupper(buff[i]);
    		  }
    		  write(connfd, buff, n);		//写回
    	  }
        fprintf(stdout, "interrupt connfd end\n");
    	  close(connfd);					//服务结束断开连接	
      }
    	return (void*)0;
    }
    
    void InitPool(TaskQueue* tp, int n) {
    	pthread_t tid;
    	int i;
    	for (i = 0; i < n; ++i) {
    		pthread_create(&tid, NULL, Routine, (void*)tp);	//此处传入tp 需要拿取任务
    		pthread_detach(tid);							//线程结束自动回收线程资源
    	}
    }
    
    int main() {
    	signal(SIGCHLD, SIG_IGN);
    	signal(SIGINT, handle);
    	tp = InitTaskQueue();//初始化任务队列
    	InitPool(tp, 3);					//一开始就开启消费者多线程
    	int listenfd, connfd;
      	pthread_t tid;
    	struct sockaddr_in serveAdd, clientAdd;
    	socklen_t clientAdd_len;
    	char ipbuff[256];
    	//创建套接字
    	if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
    		ERR_EXIT("socket");	//协议家族 服务类型(套接字类型), 协议弃用(0)
    	}
    	//确定服务端地址簇
    	bzero(&serveAdd, sizeof(serveAdd));					//清0
    	serveAdd.sin_family = AF_INET;
    	serveAdd.sin_port = htons(SERVE_PORT);
    	serveAdd.sin_addr.s_addr = htonl(INADDR_ANY);		//注意转网络字节序
    	//bind 端口 地址信息
    	if (bind(listenfd, (SA*)&serveAdd, sizeof(serveAdd)) == -1) {
    		ERR_EXIT("bind");
    	}
    	//开始监听..
    	if (listen(listenfd, 3) == -1) {
    		ERR_EXIT("listen");
    	}
    	printf("Accepting connections..\n");
    	//循环不断的接收客户的连接请求进行服务
    	while (1) {
    		clientAdd_len = sizeof(clientAdd);
    		if ((connfd = accept(listenfd, (SA*)&clientAdd, &clientAdd_len)) == -1) {
    			ERR_EXIT("accept");
    		}
    		printf("recieve connection from ip is %s and port is %d\n",
    			inet_ntop(AF_INET, &clientAdd.sin_addr, ipbuff, sizeof(ipbuff)), 
    		ntohs(clientAdd.sin_port)); 
    		Task* newtask = GetNewTask(connfd);
    		Push(tp, newtask);
    	}																	
    	return 0;
    }

然后是上述所有服务端均可通用的客户端代码:

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define SERVE_PORT 12345								//端口号
#define ERR_EXIT(m)\
	do { perror(m); exit(EXIT_FAILURE); } while (0)     //错误处理
typedef struct sockaddr SA;								
int sockfd;												//设置全局, 方便关闭
void handle(int signo) {
	fprintf(stdout, "ByeBye!\n");
	close(sockfd);
	exit(EXIT_SUCCESS);
}
int main(int argc, char* argv[]) {
	if (argc != 2) {
		fprintf(stderr, "%s ", argv[0]);
		close(EXIT_FAILURE);
	}
	signal(SIGINT, handle);
	struct sockaddr_in serveAdd;
	//创建套接字
	if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
		ERR_EXIT("socket");	//协议家族 服务类型(套接字类型), 协议弃用(0)
	}
		//确定服务端地址簇
	bzero(&serveAdd, sizeof(serveAdd));					//清0
	serveAdd.sin_family = AF_INET;
	serveAdd.sin_port = htons(SERVE_PORT);
	//将传入的ip字符串转换为 sin_addr
	if (inet_pton(AF_INET, argv[1], &serveAdd.sin_addr) == -1) {
		ERR_EXIT("inet_ntop");
	} 
	//不需要绑定端口号 系统随机分配一个临时端口号, 直接连接
	if (connect(sockfd, (SA*)&serveAdd, sizeof(serveAdd)) == -1) {
		ERR_EXIT("connect");
	}
	while (1) {										//死循环, 使用ctrl c信号关闭连接
		char buff[1024];
		printf("请说>>");
		scanf("%s", buff);
		write(sockfd, buff, strlen(buff));
		int n = read(sockfd, buff, sizeof(buff));
		if (n == -1) {
			ERR_EXIT("read");
		}
		buff[n] = 0;
		fprintf(stdout, ">>%s\n", buff);
	}
}

五. 总结本章

  • 本文首先通过 同步阻塞的原因 引出来 主线程被阻塞处理 网络 IO 服务了, 这样当他服务一个客户的时候, 其他客户都无法与服务器建立连接. 
  • 然后为了解决这个问题  提出来了  多进程 多线程模型 线程池模型 多路IO复用(遗留)
  • 目的最终是为了解决 C10k 问题, 多进程 弊端分析(进程创建销毁, 切换) 系统资源耗费巨大, 最多支持 100 左右用户
  • 为了减少系统资源消耗  + 减少切换压力, ----  引出来 多线程模型, 多个线程共享所在进程中的进程资源,  线程间切换  仅仅只是线程私有数据和寄存器的切换(切换压力小)但是不停的创建销毁线程压力大
  • 于是又引出来 线程池来实现线程的复用, 减去线程不停创建和销毁的压力
  • C10k 问题就成为本章留疑了, 大家可以先自行讨论, 评论区给与简易,以及多路复用的含义解释呀等。。。。 总结时候如果存在不清晰读者可回溯 

本文仅为自主学习复习使用, 借鉴了部分网络资源, 如果有不同意见,都可留言讨论,共同学习进步

你可能感兴趣的:(计算机网络,服务器,网络,tcp/ip,后端)