服务器并发

最新推荐文章于 2023-12-28 18:58:23 发布
最新推荐文章于 2023-12-28 18:58:23 发布
阅读量119 收藏
点赞数
文章标签： 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Alienfeng/article/details/132356671
版权

服务器概念

在网络服务器的程序当中，一般来说是一个服务器处理多个客户端。为了处理多个客户机的请求，服务器端的程序有不同的处理方式，目前最常用的服务器模型有两种：

  • 循环服务器： 也就是简单的在某一个时刻只能响应一个客户端的请求。
  • 并发服务器：在某一时刻可以响应多个客户端的请求。

循环服务器

  • 就是简单的socket编程流程，整个服务器在某一时刻只能连接一个客户端并且只为该连接提供服务，一般不适用。

并发服务器

  • 并发服务器在同一时刻可以响应多个客户端请求，一般有以下两种方式。
  1. 多进程并发服务器
  2. 多线程并发服务器
  3. IO多路复用并发服务器

多进程并发服务器

基本思想：建立连接和通信要分开分别使用不同的进程完成。父进程等待客户端来连接（使用的是listenfd），只要有客户端连接成功（就会产生一个新的confd）就创建子进程用来和客户端进行通信，不同的子进程使用的是不同的confd。使用信号注册（signal）其中当子进程状态发生改变时会父进程执行资源回收。

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <signal.h>
 
 
void sigFunc(int sigNo)
{
	int ret;
	if(SIGCHLD == sigNo)
	{
		ret = waitpid(-1, NULL,  WNOHANG);
		if(0 == ret)
		{
			printf("子进程状态发生改变!\n");
		}
		else
		{
			printf("子进程已被回收!\n");
		}
	}
}
 
 
int main()
{
	//监听套接字文件描述符
	int listenfd = -1;
	//连接套接字的文件描述符
	int confd = -1;
	//服务器的地址结构
	struct sockaddr_in servAddr = {0};
	//客户端的地址结构
	struct sockaddr_in cliAddr = {0};
	socklen_t len = sizeof(cliAddr);
	int ret;
	char buf[100] = {0};
	pid_t pid = -1;
 
	//创建套接字
	listenfd = socket(PF_INET, SOCK_STREAM, 0);
	if(listenfd < 0)
	{
		perror("socket error!\n");
		return -1;
	}
	printf("socket ok!\n");
	//绑定ip地址和端口号
	servAddr.sin_family = PF_INET;
	servAddr.sin_port = htons(10086);
	servAddr.sin_addr.s_addr = inet_addr("0.0.0.0");
	ret = bind(listenfd, (struct sockaddr *)&servAddr, sizeof(servAddr));
	if(ret < 0)
	{
		perror("bind error!");
		close(listenfd);
		return -1;
	}
	printf("bind ok!\n");
	//创建监听队列（使得主动的套接字变成可以被连接的被动套接字）
	ret = listen(listenfd, 1);
	if(ret < 0)
	{
		perror("listen error");
		close(listenFd);
		return -1;
	}
 
	while(1)
	{
		//父进程
		printf("listening....\n");
		//等待并建立连接
		confd = accept(listenfd, (struct sockaddr *)&cliAddr, &len);
		if(confd < 0)
		{
			perror("accept error!");
			close(listenfd);
			return -1;
		}
		printf("IP:%s,PORT:%d accept ok!\n", inet_ntoa(cliAddr.sin_addr), ntohs(cliAddr.sin_port));
 
		//创建子进程
		while(-1 == (pid = fork()));  //创建成功while循环结束
		if(pid > 0)
		{
			//父进程
			//子进程状态发生改变时，父进程会收到SIGCHLD的信号
			signal(SIGCHLD, sigFunc);
 
			close(confd);
		}
		else
		{
			//子进程
			//只用来和客户端通信
			//通信结束进程退出
			while(1)
			{
                close(listenfd);
				memset(buf, 0, sizeof(buf));
				//接收消息并打印
				ret = recv(confd, buf, sizeof(buf), 0);
				if(ret < 0)
				{
					perror("recv error!");
					close(listenfd);
					close(connfd);
					return -1;
				}
				else if(0 == ret)
				{
					printf("client quit!\n");
					//子进程退出
					exit(0);
				}
				printf("recv:%s\n", buf);
				memset(buf, 0, sizeof(buf));
		        strcat(buf, " play.....");
 
				int i;
				for(i = 0; i < 3; i++)
				{
					//发送消息
					ret = send(confd, buf, sizeof(buf), 0);
					if(ret < 0)
					{
						perror("send error!");
						close(confd);
						return -1;
					}
			        printf("send ok!\n");
					sleep(1);
				}
				strcpy(buf, "end");
				send(confd, buf, sizeof(buf), 0);
			}
		}
	}
	//关闭套接字
	//子进程执行不到这里就退出了
	close(listenFd);
	return 0;
}

多线程服务器

基本思想：建立连接和通信要分开分别使用不同的线程完成。父进程等待客户端来连接（使用的是listenfd），只要有客户端连接成功（就会产生一个新的confd）就创建子线程用来和客户端进行通信，不同的子进程使用的是不同的confd。

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <signal.h>
#include <pthread.h>
 
 
void *thread_func(void *arg)
{
	char buf[100] = {0};
	int connFd = *((int *)arg);
	int ret;
	//子线程
	//只用来和客户端通信
	//通信结束线程退出
	while(1)
	{
		memset(buf, 0, sizeof(buf));
		//接收消息并打印
		ret = recv(connFd, buf, sizeof(buf), 0);
		if(ret < 0)
		{
			perror("recv error!");
			close(connFd);
			return (void *)-1;
		}
		else if(0 == ret)
		{
			printf("client quit!\n");
			//子线程退出
			pthread_exit(NULL);
		}
		printf("recv:%s\n", buf);
		memset(buf, 0, sizeof(buf));
		strcat(buf, " play.....");
 
		int i;
		for(i = 0; i < 3; i++)
		{
			//发送消息
			ret = send(connFd, buf, sizeof(buf), 0);
			if(ret < 0)
			{
				perror("send error!");
				close(connFd);
				return (void *)-1;
			}
			printf("send ok!\n");
			sleep(1);
		}
		strcpy(buf, "end");
		send(connFd, buf, sizeof(buf), 0);
	}
    return NULL;
}
 
 
 
 
int main()
{
	//监听套接字文件描述符
	int listenfd = -1;
	//连接套接字的文件描述符
	int confd = -1;
	//服务器的地址结构
	struct sockaddr_in servAddr = {0};
	//客户端的地址结构
	struct sockaddr_in cliAddr = {0};
	socklen_t len = sizeof(cliAddr);
	int ret;
	pthread_t tid;
 
	//创建套接字
	listenfd = socket(PF_INET, SOCK_STREAM, 0);
	if(listenfd < 0)
	{
		perror("socket error!\n");
		return -1;
	}
	printf("socket ok!\n");
	//绑定ip地址和端口号
	servAddr.sin_family = PF_INET;
	servAddr.sin_port = htons(10086);
	servAddr.sin_addr.s_addr = inet_addr("0.0.0.0");
	ret = bind(listenFd, (struct sockaddr *)&servAddr, sizeof(servAddr));
	if(ret < 0)
	{
		perror("bind error!");
		close(listenfd);
		return -1;
	}
	printf("bind ok!\n");
	//创建监听队列（使得主动的套接字变成可以被连接的被动套接字）
	ret = listen(listenfd, 1);
	if(ret < 0)
	{
		perror("listen error");
		close(listenfd);
		return -1;
	}
 
	while(1)
	{
		//主线程
		printf("listening....\n");
		//等待并建立连接
		confd = accept(listenfd, (struct sockaddr *)&cliAddr, &len);
		if(confd < 0)
		{
			perror("accept error!");
			close(listenfd);
			return -1;
		}
		printf("IP:%s,PORT:%d accept ok!\n", inet_ntoa(cliAddr.sin_addr), ntohs(cliAddr.sin_port));
 
		//创建子线程
		while(0 != pthread_create(&tid, NULL, thread_func, &confd));
 
		//将子线程设置为分离态
		//分离态的线程在终止时资源会自动被系统回收
		pthread_detach(tid);
	}
	//关闭套接字
	//子进程执行不到这里就退出了
	close(listenfd);
	return 0;
}

IO多路复用并发服务器

使用一个进程可以处理多路IO（这里的IO指的是客户的连接），其中要使用IO多路复用达到真正的百万服务器并发需要的是存储模型也就是每个IO的内存应该如何存储，并且使用REACTOR反应堆模型。

  • 使用hash的存储模型
  1. 将1024个IO设置为一组，将这一组抽象为IO块。
struct eventblock {

	struct eventblock *next;
	struct event *events;
	
};

其中struct event 结构体详细为：

struct event {
	int fd;
	int events;
	void *arg;
	int (*callback)(int fd, int events, void *arg);
	
	int status;
	char buffer[BUFFER_LENGTH];
	int length;
	long last_active;
};

由此可以看见IO内存设置为：
在这里插入图片描述

  • struct event *events指向的是每一个IO块的首地址
#define MAX_EPOLL_EVENTS 1024

struct event *evs = (struct ntyevent*)malloc((MAX_EPOLL_EVENTS) * sizeof(struct event));

在这里插入图片描述

  • 如何确定某一个连接存储的位置呢？
  • 冷知识：fd是递增的。
    1.先确定IO组（confd / MAX_EPOLL_EVENTS ）
    2.再确定目标组的位置（confd % MAX_EPOLL_EVENTS）
struct event *ntyreactor_idx(struct ntyreactor *reactor, int sockfd) {

	int blkidx = sockfd / MAX_EPOLL_EVENTS;

	while (blkidx >= reactor->blkcnt) {
		ntyreactor_alloc(reactor);
	}

	int i = 0;
	struct eventblock *blk = reactor->evblk;
	while(i ++ < blkidx && blk != NULL) {
		blk = blk->next;
	}

	return &blk->events[sockfd % MAX_EPOLL_EVENTS];
}

到此百万并发服务器的连接就搞定了，但是离真正的百万并发还差一个线程池。

@Era
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
多进程/多线程实现服务器的并发
oorik的博客
09-24 1900
上一节提到的 TCP Socket 调用流程是最简单、最基本的，它基本只能一对一通信，因为使用的是同步阻塞的方式，当服务端在还没处理完一个客户端的网络 I/O 时，或者 读写操作发生阻塞时，其他客户端是无法与服务端连接的。本节我们讲讲最简单的两种方式，使用多线程和多进程实现服务器的并发。
性能测试并发数以及服务器,怎么测试服务器并发数
weixin_36035610的博客
08-11 1750
怎么测试服务器并发数 内容精选换一换使用Benchmark工具测试MySQL并发100个进程的性能数据。cd /home/ BenchMarkSQL/run怎么测试服务器并发数 相关内容云硬盘(Elastic Volume Service，EVS)可以为弹性云服务器提供高可靠、高性能、规格丰富并且可弹性扩展的块存储服务，满足不同场景的业务需求，适用于分布式文件系统、开发测试、数据仓库以及高性能计算...
并发服务器
weixin_57539783的博客
12-12 1116
并发服务器
web 服务器 - 并发服务器 - 2
apollo_miracle的博客
08-04 1173
1 Web静态服务器 在“HTTP协议、http服务器的实现-1”中已经完成了“根据用户的需求返回相应的页面”的任务，接下分别使用多进程、多线程、协程gevent，来完成http服务器。 1.1 使用多进程完成http服务器 import socket import re import multiprocessing def service_client(new_socket): ...
网络程序设计：并发服务器设计
最新发布
z7x89的博客
12-28 844
多进程服务器：通过创建多个进程提供服务多路复用服务器：通过捆绑并统一管理 I/O 对象提供服务多线程服务器：通过生成与客户端等量的线程提供服务非常荣幸能够参加孟宁老师的这门课程。在这次的学习过程中，无论是对JavaScript网络编程，前端应用，还是socket网络编程，高并发服务器，亦或是网络协议设计，RPC，我都有了新的理解与认知。孟宁老师的教学风格轻松幽默，能够把复杂的概念以简单明了的方式呈现出来，让我们这些初学者也能够轻松理解。互动式的教学方式让我们更加深入地理解课程内容。
服务器并发处理.pptx
09-26
服务器并发处理技术详解 服务器并发处理是指服务器同时处理多个请求或任务的能力，是一种提高服务器性能和响应速度的技术。并发处理可以分为两种：真正的并发（并行：Parallelism）和表面上的并发（并发：...
百万服务器并发代码实现
05-27
在IT行业中，面对大规模并发场景，如"百万服务器并发"，高效的编程技术和策略至关重要。这里的"百万服务器并发代码实现"通常涉及到分布式系统、网络编程、多线程与异步处理等多个核心领域。以下是对这些知识点的详细...
Python多进程与服务器并发原理及用法实例分析
09-20
本篇将深入探讨Python多进程与服务器并发的原理，并提供相关的实践示例。 首先，我们来了解几个基本概念： 1. **进程**：进程是操作系统资源分配的基本单位，它代表了程序的一次执行实例。每个进程都有独立的内存...
优化Linux的内核提高服务器并发能力
07-12
在Linux系统中，服务器并发能力的提升是通过各种优化手段实现的。Linux的内核优化是一个复杂且效果显著的方法，尤其在硬件资源有限的情况下，通过调整内核参数来提高并发处理能力，能够有效提高服务器性能。服务器...
高并发服务器
coffee0218的博客
03-27 454
多进程并发服务器 client.c /* client.c */ #include <stdio.h> #include <string.h> #include <unistd.h> #include <netinet/in.h> #include <arpa/inet.h> #include "wrap.h" #define ...
并发服务器：共五种方式实现
m0_69124108的博客
02-17 572
并发服务器：共五种方式实现
服务器两种高效的并发模式
仗剑天涯
07-16 943
服务器两种高性能并发模式
服务器并发处理是什么？
weixin_45433211的博客
11-03 682
服务器攻击并发是什么?如何预防攻击
服务器并发影响元素
Lostboy船长
08-13 1267
一：服务器并发数取决于那些？ 1. CPU 处理性能 CPU 核数，假如 CPU有4个核，处理每个访问请求用线程去处理，那么4核每次最大能处理不超过8个线程，处理时间看单个线程处理完数据的时间，假如一个线程处理时间是40ms(毫秒)，那么最高秒级并发计算那就是 1000/40*8=200 那么每秒最高处理并发是200个，如果服务器只收不处理数据的话处理时间还能大幅度下降， 并发数还鞥你大幅度提...
服务器高并发的解决方法
vecloud的博客
08-10 4406
服务器高并发三种解决方法为： 高并发问题是大部分服务器都经历过的，由于资源的有限性，其同时处理请求的能力自然也有限制。当高并发出现时，服务端的处理和响应速度会大幅降低，更严重的会使服务器崩溃。那么，当遇见服务器高并发时，应该怎么处理呢？ 一、减少请求数量 高并发的主要原因之一就是请求量过于庞大，以致超出服务器的承受范围，因此想要解决问题就需要在这方面做出处理，一是需要避免重复的请求消耗不必要的资源，二是通过客户端自身的处理能力来响应请求，而不必到达服务端。 二、配置优化 如果请求量...
实现TCP并发服务器
weixin_47783699的博客
11-25 2630
详解实现TCP并发服务器两种方法:1、使用多进程实现TCP并发服务器2、使用多线程实现TCP并发服务器。
高并发服务器的限制有哪些,如何提高并发量
小杰312的博客
05-30 3686
高并发服务器的限制有哪些,如何提高并发量
关于服务器并发量的简单计算
tabianY的专栏
04-14 3333
最简单的计算方式就是根据服务器带宽与页面的大小 1.假设机房带宽为10Mbs，页面的大小为20KB（包含所有的js、css、图片） 同时并发量的理论值： 10*1024/(8*20) = 64个请求/秒 理论上1秒钟同时可以有64个请求访问页面。 注意：10Mbs是位(b)，1个字节8位，所以要除8。 2. 假设进来的人是匀速的增加， 根据”三秒定律”（页面打开速度3秒），可得出并发量在单位时间内应是192个请求； 一分钟的请求量在3840。 3...
服务器并发处理技术与I/O模型详解
"服务器并发处理.pptx - 服务器并发处理培训讲义" 在IT行业中，服务器并发处理是一项至关重要的技术，特别是在高流量的互联网应用和大规模分布式系统中。并发处理使得服务器能够同时处理多个请求，提高系统效率和...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值