支持百万并发的服务器测试

最新推荐文章于 2024-05-11 07:32:45 发布
最新推荐文章于 2024-05-11 07:32:45 发布
阅读量1k 收藏 2
点赞数
分类专栏： Linux高性能服务器编程 文章标签： 服务器 网络 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51721904/article/details/125899608
版权

支持百万并发和实现百万并发不是一个意思，能支持是实现的前提，本篇带你在配置较差的情况下，实现一个支持百万并发的服务器连接测试。

原理：基于epoll的Reactor模式。绝大多数的开源服务器框架，底层都是使用的epoll，Reactor是一种高效事件处理模式。

实验条件：准备四台虚拟机，一台当作服务器使用，另外三台当作客户端不断请求连接。如果你的实验环境和我一样，本机配置较差，可以只用两台虚拟机，一台做服务器，一台做客户机，客户机只需达到340000的连接，即可表明，三台客户机就可以达到上百万的并发连接。

在开始之前，我们先了解一下socket
socket的英文名是插座的意思，它是客户端和服务器建立通信连接的唯一标识，为何说它唯一，因为它是由五元组(源端口，目的端口，源ip，目的ip，通信协议)构成的，我们要知道，目的端口，源ip和目的ip都是确定的，这里唯一可以改变的就是源端口，我们都知道总的端口号也就是65535个，而且在一个进程中，默认单个进程能使用的端口号大概是28000(可以自己设置，但并没有解决实际问题)，所以就目前的情况来看单个端口是不行的。
实验过程中会遇到的问题：
1.一个进程的默认支持打开文件数为1024，有的是65535，但这显然是不够的，可以通过ulimit -a 来看到，我们可以看到表示最大文件描述符打开数的对应条目是 -n ，我们可以通过ulimit -n 数字 来修改最大打开文件描述符数量，其他数值同理。
这里我们先修改成ulimit -n 1024576，足够一百万使用了。
当然这种方式修改后重启后就没有了
可以在 /etc/sysctl.conf 下添加如下对fs.file-max值得修改，再往下一行表示得是tcp协议栈占用内存大小的现在，最后两行表示的是套接字发送和接收缓冲区的大小，可以看出每项都对应3个值，中间表示默认值，左边是最小值，右边是最大值。
在这里插入图片描述
2.若只使用一个端口，那么最大连接数目在28000左右，当然我们可以自己设置，但意义不大，没有解决实际问题，这里我们可以使用监听多个端口的方式，当然，在实际开发中，我们不会使用监听多端口的方式，而是使用多进程，这里有朋友可能要问，为什么是多进程而不是多线程，因为多线程的本质是同一个进程，没有扩大可打开的文件描述符数量，而每个进程拥有它独立的文件系统空间，所以我们需要使用多进程。
3. 客户端在连接进行到65535左右的时候还会出现问题，这里是由于，客户端本身对于一个进程的connect连接数量有限制，当到达一定的限制后，就无法发送出connect连接的消息，这里我们需要在 /etc/sysctl.conf 下添加如下内容来接触限制。
在这里插入图片描述到此为止就可以完成测试了，需要注意的一点是做服务器的那台虚拟机，内存必须设置的大一点，因为每一个socket都含有发送和接收缓冲区，它们占用一定的内存空间，上百万的连接，自然要耗费不少空间，如果使用两台虚拟机进行测试，建议服务器端内存设置在8个G。当然，我们可以通过setsockopt这个函数设置socket的接受和发送缓冲区的大小，越小，同一内存大小的机器上就可以接受更多的连接。

单台客户机测试效果：
在这里插入图片描述达到了340000万的连接数，没截图，这里是断开连接时的效果，可以看到fd数量在30多万。

若在自行测试的过程中遇到任何问题， 欢迎评论区留言。

服务器端代码：
有两版，这一版是单线程的，下面会给出一般使用了池的代码提高效率



#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <unistd.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <pthread.h>

#include <errno.h>
#include <sys/epoll.h>

#define BUFFER_LENGTH		1024
#define LISTEN_PORT 		100

struct sockitem { //
	int sockfd;
	int (*callback)(int fd, int events, void *arg);

	char recvbuffer[BUFFER_LENGTH]; //
	char sendbuffer[BUFFER_LENGTH];

	int rlength;
	int slength;
};

// mainloop / eventloop --> epoll -->  
struct reactor {

	int epfd;
	struct epoll_event events[512];
	
	

};


struct reactor *eventloop = NULL;


int recv_cb(int fd, int events, void *arg);


int send_cb(int fd, int events, void *arg) {

	struct sockitem *si = (struct sockitem*)arg;

	send(fd, si->sendbuffer, si->slength, 0); //

	struct epoll_event ev;
	ev.events = EPOLLIN | EPOLLET;
	//ev.data.fd = clientfd;
	si->sockfd = fd;
	si->callback = recv_cb;
	ev.data.ptr = si;

	epoll_ctl(eventloop->epfd, EPOLL_CTL_MOD, fd, &ev);

}

//  ./epoll 8080

int recv_cb(int fd, int events, void *arg) {

	//int clientfd = events[i].data.fd;
	struct sockitem *si = (struct sockitem*)arg;
	struct epoll_event ev;

	//char buffer[1024] = {0};
	int ret = recv(fd, si->recvbuffer, BUFFER_LENGTH, 0);
	if (ret < 0) {

		if (errno == EAGAIN || errno == EWOULDBLOCK) { //
			return -1;
		} else {
			
		}

		

		ev.events = EPOLLIN;
		//ev.data.fd = fd;
		epoll_ctl(eventloop->epfd, EPOLL_CTL_DEL, fd, &ev);

		close(fd);

		free(si);
		

	} else if (ret == 0) { //

		// 
		printf("disconnect %d\n", fd);

		ev.events = EPOLLIN;
		//ev.data.fd = fd;
		epoll_ctl(eventloop->epfd, EPOLL_CTL_DEL, fd, &ev);

		close(fd);

		free(si);
		
	} else {

		printf("Recv: %s, %d Bytes\n", si->recvbuffer, ret);

		si->rlength = ret;
		memcpy(si->sendbuffer, si->recvbuffer, si->rlength);
		si->slength = si->rlength;

		struct epoll_event ev;
		ev.events = EPOLLOUT | EPOLLET;
		//ev.data.fd = clientfd;
		si->sockfd = fd;
		si->callback = send_cb;
		ev.data.ptr = si;

		epoll_ctl(eventloop->epfd, EPOLL_CTL_MOD, fd, &ev);

	}

}


int accept_cb(int fd, int events, void *arg) {

	struct sockaddr_in client_addr;
	memset(&client_addr, 0, sizeof(struct sockaddr_in));
	socklen_t client_len = sizeof(client_addr);
	
	int clientfd = accept(fd, (struct sockaddr*)&client_addr, &client_len);
	if (clientfd <= 0) return -1;

	char str[INET_ADDRSTRLEN] = {0};
	printf("recv from %s at port %d\n", inet_ntop(AF_INET, &client_addr.sin_addr, str, sizeof(str)),
		ntohs(client_addr.sin_port));

	struct epoll_event ev;
	ev.events = EPOLLIN | EPOLLET;
	//ev.data.fd = clientfd;

	struct sockitem *si = (struct sockitem*)malloc(sizeof(struct sockitem));
	si->sockfd = clientfd;
	si->callback = recv_cb;
	ev.data.ptr = si;
	
	epoll_ctl(eventloop->epfd, EPOLL_CTL_ADD, clientfd, &ev);
	
	return clientfd;
}

int init_sock(short port) {
	int sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if (sockfd < 0) {
		return -1;
	}

	struct sockaddr_in addr;
	memset(&addr, 0, sizeof(struct sockaddr_in));

	addr.sin_family = AF_INET;
	addr.sin_port = htons(port);
	addr.sin_addr.s_addr = inet_addr("192.168.5.128");
	//addr.sin_addr.s_addr = INADDR_ANY;

	if (bind(sockfd, (struct sockaddr*)&addr, sizeof(struct sockaddr_in)) < 0) {
		return -2;
	}

	if (listen(sockfd, 5) < 0) {
		return -3;
	}
	printf("port:%d\n", port);
	return sockfd;
}
int main(int argc, char *argv[]) {

	if (argc < 2) {
		return -1;
	}

	eventloop = (struct reactor*)malloc(sizeof(struct reactor));
	// epoll opera

	eventloop->epfd = epoll_create(1);
	int port = atoi(argv[1]);

	for(int i = 0; i < LISTEN_PORT; i++) {
		int sockfd = init_sock(port + i);
		struct epoll_event ev;
		ev.events = EPOLLIN;
		
		struct sockitem *si = (struct sockitem*)malloc(sizeof(struct sockitem));
		si->sockfd = sockfd;
		si->callback = accept_cb;
		ev.data.ptr = si;
	
	epoll_ctl(eventloop->epfd, EPOLL_CTL_ADD, sockfd, &ev);
	}

	

	
	
	

	while (1) {

		int nready = epoll_wait(eventloop->epfd, eventloop->events, 512, -1);
		if (nready < -1) {
			break;
		}

		int i = 0;
		for (i = 0;i < nready;i ++) {



			if (eventloop->events[i].events & EPOLLIN) {
				//printf("sockitem\n");
				struct sockitem *si = (struct sockitem*)eventloop->events[i].data.ptr;
				si->callback(si->sockfd, eventloop->events[i].events, si);

			}

			if (eventloop->events[i].events & EPOLLOUT) {

				struct sockitem *si = (struct sockitem*)eventloop->events[i].data.ptr;
				si->callback(si->sockfd, eventloop->events[i].events, si);

			}
		}

	}

}

服务器端代码（使用池）：建议使用




#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <arpa/inet.h>

#include <fcntl.h>
#include <unistd.h>
#include <errno.h>


#define BUFFER_LENGTH		1024
#define MAX_EPOLL_EVENTS	1024*1024 //connection 
#define MAX_EPOLL_ITEM		102400 //con
#define SERVER_PORT			8888

#define LISTEN_PORT_COUNT	100

typedef int NCALLBACK(int ,int, void*);

struct ntyevent {
	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;
};



struct ntyreactor {
	int epfd;
	struct ntyevent *events; // 1024 * 1024
};


int recv_cb(int fd, int events, void *arg);
int send_cb(int fd, int events, void *arg);


void nty_event_set(struct ntyevent *ev, int fd, NCALLBACK callback, void *arg) {

	ev->fd = fd;
	ev->callback = callback;
	ev->events = 0;
	ev->arg = arg;
	ev->last_active = time(NULL);

	return ;
	
}


int nty_event_add(int epfd, int events, struct ntyevent *ev) {

	struct epoll_event ep_ev = {0, {0}};
	ep_ev.data.ptr = ev;
	ep_ev.events = ev->events = events;

	int op;
	if (ev->status == 1) {
		op = EPOLL_CTL_MOD;
	} else {
		op = EPOLL_CTL_ADD;
		ev->status = 1;
	}

	if (epoll_ctl(epfd, op, ev->fd, &ep_ev) < 0) {
		printf("event add failed [fd=%d], events[%d]\n", ev->fd, events);
		return -1;
	}

	return 0;
}

int nty_event_del(int epfd, struct ntyevent *ev) {

	struct epoll_event ep_ev = {0, {0}};

	if (ev->status != 1) {
		return -1;
	}

	ep_ev.data.ptr = ev;
	ev->status = 0;
	epoll_ctl(epfd, EPOLL_CTL_DEL, ev->fd, &ep_ev);

	return 0;
}

int recv_cb(int fd, int events, void *arg) {

	struct ntyreactor *reactor = (struct ntyreactor*)arg;
	struct ntyevent *ev = reactor->events+fd;

	int len = recv(fd, ev->buffer, BUFFER_LENGTH, 0);
	nty_event_del(reactor->epfd, ev);

	if (len > 0) {
		
		ev->length = len;
		ev->buffer[len] = '\0';

		printf("C[%d]:%s\n", fd, ev->buffer);

		nty_event_set(ev, fd, send_cb, reactor);
		nty_event_add(reactor->epfd, EPOLLOUT, ev);
		
		
	} else if (len == 0) {

		close(ev->fd);
		printf("[fd=%d] pos[%ld], closed\n", fd, ev-reactor->events);
		 
	} else {

		close(ev->fd);
		printf("recv[fd=%d] error[%d]:%s\n", fd, errno, strerror(errno));
		
	}

	return len;
}


int send_cb(int fd, int events, void *arg) {

	struct ntyreactor *reactor = (struct ntyreactor*)arg;
	struct ntyevent *ev = reactor->events+fd;

	int len = send(fd, ev->buffer, ev->length, 0);
	if (len > 0) {
		printf("send[fd=%d], [%d]%s\n", fd, len, ev->buffer);

		nty_event_del(reactor->epfd, ev);
		
		nty_event_set(ev, fd, recv_cb, reactor);
		nty_event_add(reactor->epfd, EPOLLIN, ev);
		
	} else {

		close(ev->fd);

		nty_event_del(reactor->epfd, ev);
		printf("send[fd=%d] error %s\n", fd, strerror(errno));

	}

	return len;
}

int accept_cb(int fd, int events, void *arg) {

	struct ntyreactor *reactor = (struct ntyreactor*)arg;
	if (reactor == NULL) return -1;

	struct sockaddr_in client_addr;
	socklen_t len = sizeof(client_addr);

	int clientfd;

	if ((clientfd = accept(fd, (struct sockaddr*)&client_addr, &len)) == -1) {
		if (errno != EAGAIN && errno != EINTR) {
			
		}
		printf("accept: %s\n", strerror(errno));
		return -1;
	}

	int i = 0;
	do {
#if 0
		for (i = 0;i < MAX_EPOLL_EVENTS;i ++) {
			if (reactor->events[i].status == 0) {
				break;
			}
		}
		if (i == MAX_EPOLL_EVENTS) {
			printf("%s: max connect limit[%d]\n", __func__, MAX_EPOLL_EVENTS);
			break;
		}
#endif
		int flag = 0;
		if ((flag = fcntl(clientfd, F_SETFL, O_NONBLOCK)) < 0) {
			printf("%s: fcntl nonblocking failed, %d\n", __func__, MAX_EPOLL_EVENTS);
			break;
		}

		nty_event_set(&reactor->events[clientfd], clientfd, recv_cb, reactor);
		nty_event_add(reactor->epfd, EPOLLIN, &reactor->events[clientfd]);

	} while (0);

	printf("new connect [%s:%d][time:%ld], pos[%d]\n", 
		inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port), reactor->events[i].last_active, i);

	return 0;

}

int init_sock(short port) {

	int fd = socket(AF_INET, SOCK_STREAM, 0);
	fcntl(fd, F_SETFL, O_NONBLOCK);

	struct sockaddr_in server_addr;
	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	server_addr.sin_port = htons(port);

	bind(fd, (struct sockaddr*)&server_addr, sizeof(server_addr));

	if (listen(fd, 20) < 0) {
		printf("listen failed : %s\n", strerror(errno));
	}

	printf("listen port : %d\n", port);

	return fd;
}


int ntyreactor_init(struct ntyreactor *reactor) {

	if (reactor == NULL) return -1;
	memset(reactor, 0, sizeof(struct ntyreactor));

	reactor->epfd = epoll_create(1);
	if (reactor->epfd <= 0) {
		printf("create epfd in %s err %s\n", __func__, strerror(errno));
		return -2;
	}

	reactor->events = (struct ntyevent*)malloc((MAX_EPOLL_EVENTS) * sizeof(struct ntyevent));
	if (reactor->events == NULL) {
		printf("create epfd in %s err %s\n", __func__, strerror(errno));
		close(reactor->epfd);
		return -3;
	}
}

int ntyreactor_destory(struct ntyreactor *reactor) {

	close(reactor->epfd);
	free(reactor->events);

}



int ntyreactor_addlistener(struct ntyreactor *reactor, int sockfd, NCALLBACK *acceptor) {

	if (reactor == NULL) return -1;
	if (reactor->events == NULL) return -1;

	nty_event_set(&reactor->events[sockfd], sockfd, acceptor, reactor);
	nty_event_add(reactor->epfd, EPOLLIN, &reactor->events[sockfd]);

	return 0;
}



int ntyreactor_run(struct ntyreactor *reactor) {
	if (reactor == NULL) return -1;
	if (reactor->epfd < 0) return -1;
	if (reactor->events == NULL) return -1;
	
	struct epoll_event events[MAX_EPOLL_ITEM];
	
	int checkpos = 0, i;

	while (1) {
#if 0
		long now = time(NULL);
		for (i = 0;i < 100;i ++, checkpos ++) {
			if (checkpos == MAX_EPOLL_EVENTS) {
				checkpos = 0;
			}

			if (reactor->events[checkpos].status != 1) {
				continue;
			}

			long duration = now - reactor->events[checkpos].last_active;

			if (duration >= 60) {
				close(reactor->events[checkpos].fd);
				printf("[fd=%d] timeout\n", reactor->events[checkpos].fd);
				nty_event_del(reactor->epfd, &reactor->events[checkpos]);
			}
		}
#endif

		int nready = epoll_wait(reactor->epfd, events, MAX_EPOLL_ITEM, 1000);
		if (nready < 0) {
			printf("epoll_wait error, exit\n");
			continue;
		}

		for (i = 0;i < nready;i ++) {

			struct ntyevent *ev = (struct ntyevent*)events[i].data.ptr;

			if ((events[i].events & EPOLLIN) && (ev->events & EPOLLIN)) {
				ev->callback(ev->fd, events[i].events, ev->arg);
			}
			if ((events[i].events & EPOLLOUT) && (ev->events & EPOLLOUT)) {
				ev->callback(ev->fd, events[i].events, ev->arg);
			}
			
		}

	}
}

int main(int argc, char *argv[]) {

	unsigned short port = SERVER_PORT;
	if (argc == 2) {
		port = atoi(argv[1]);
	}
	struct ntyreactor *reactor = (struct ntyreactor*)malloc(sizeof(struct ntyreactor));
	ntyreactor_init(reactor);
	

	int listenfd[LISTEN_PORT_COUNT] = {0};
	int i = 0;

	for (i = 0;i < LISTEN_PORT_COUNT;i ++) {
		listenfd[i] = init_sock(port+i);
		ntyreactor_addlistener(reactor, listenfd[i], accept_cb);
	}
	
	ntyreactor_run(reactor);

	ntyreactor_destory(reactor);

	for (i = 0;i < LISTEN_PORT_COUNT;i ++) {
		close(listenfd[i]);
	}
	

	return 0;
}

客户端代码



#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <errno.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <fcntl.h>
#include <unistd.h>


#define MAX_BUFFER		128
#define MAX_EPOLLSIZE	(384*1024)
#define MAX_PORT		100

#define TIME_SUB_MS(tv1, tv2)  ((tv1.tv_sec - tv2.tv_sec) * 1000 + (tv1.tv_usec - tv2.tv_usec) / 1000)

int isContinue = 0;

static int ntySetNonblock(int fd) {
	int flags;

	flags = fcntl(fd, F_GETFL, 0);
	if (flags < 0) return flags;
	flags |= O_NONBLOCK;
	if (fcntl(fd, F_SETFL, flags) < 0) return -1;
	return 0;
}

static int ntySetReUseAddr(int fd) {
	int reuse = 1;
	return setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *)&reuse, sizeof(reuse));
}



int main(int argc, char **argv) {
	if (argc <= 2) {
		printf("Usage: %s ip port\n", argv[0]);
		exit(0);
	}

	const char *ip = argv[1];
	int port = atoi(argv[2]);
	int connections = 0;
	char buffer[128] = {0};
	int i = 0, index = 0;

	struct epoll_event events[MAX_EPOLLSIZE];
	
	int epoll_fd = epoll_create(MAX_EPOLLSIZE);
	
	strcpy(buffer, " Data From MulClient\n");
		
	struct sockaddr_in addr;
	memset(&addr, 0, sizeof(struct sockaddr_in));
	
	addr.sin_family = AF_INET;
	addr.sin_addr.s_addr = inet_addr(ip);

	struct timeval tv_begin;
	gettimeofday(&tv_begin, NULL);

	while (1) {
		if (++index >= MAX_PORT) index = 0;
		
		struct epoll_event ev;
		int sockfd = 0;

		if (connections < 340000 && !isContinue) {
			sockfd = socket(AF_INET, SOCK_STREAM, 0);
			if (sockfd == -1) {
				perror("socket");
				goto err;
			}

			//ntySetReUseAddr(sockfd);
			addr.sin_port = htons(port+index);

			if (connect(sockfd, (struct sockaddr*)&addr, sizeof(struct sockaddr_in)) < 0) {
				perror("connect");
				goto err;
			}
			ntySetNonblock(sockfd);
			ntySetReUseAddr(sockfd);

			sprintf(buffer, "Hello Server: client --> %d\n", connections);
			send(sockfd, buffer, strlen(buffer), 0);

			ev.data.fd = sockfd;
			ev.events = EPOLLIN | EPOLLOUT;
			epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sockfd, &ev);
		
			connections ++;
		}
		//connections ++;
		if (connections % 1000 == 999 || connections >= 340000) {
			struct timeval tv_cur;
			memcpy(&tv_cur, &tv_begin, sizeof(struct timeval));
			
			gettimeofday(&tv_begin, NULL);

			int time_used = TIME_SUB_MS(tv_begin, tv_cur);
			printf("connections: %d, sockfd:%d, time_used:%d\n", connections, sockfd, time_used);

			int nfds = epoll_wait(epoll_fd, events, connections, 100);
			for (i = 0;i < nfds;i ++) {
				int clientfd = events[i].data.fd;

				if (events[i].events & EPOLLOUT) {
					sprintf(buffer, "data from %d\n", clientfd);
					send(sockfd, buffer, strlen(buffer), 0);
				} else if (events[i].events & EPOLLIN) {
					char rBuffer[MAX_BUFFER] = {0};				
					ssize_t length = recv(sockfd, rBuffer, MAX_BUFFER, 0);
					if (length > 0) {
						printf(" RecvBuffer:%s\n", rBuffer);

						if (!strcmp(rBuffer, "quit")) {
							isContinue = 0;
						}
						
					} else if (length == 0) {
						printf(" Disconnect clientfd:%d\n", clientfd);
						connections --;
						close(clientfd);
					} else {
						if (errno == EINTR) continue;

						printf(" Error clientfd:%d, errno:%d\n", clientfd, errno);
						close(clientfd);
					}
				} else {
					printf(" clientfd:%d, errno:%d\n", clientfd, errno);
					close(clientfd);
				}
			}
		}

		usleep(1 * 1000);
	}

	return 0;

err:
	printf("error : %s\n", strerror(errno));
	return 0;
	
}
江游Infinite
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
百万并发测试
A152419的博客
11-29 929
在网上看到什么百万并发之类的，感觉很高大上，也看了一些学习视频，决定自己测试一下，满足一下好奇心，同时也学习一些知识。本次主要在已经准备好的源码上对系统参数做出一些调整。虽然过程并不算复杂，但是自己搭建环境，实际操作下来确实会有更加直观的感受，就是有一点遗憾没有到达 100 万的并发。希望大家有时间可以自己试试。
百看不如一练，动手测试单机百万连接的保姆级教程！
zhangyanfei01的专栏
02-24 575
点击上方蓝字"开发内功修炼"，关注并设为星标飞哥的硬核文章将第一时间送达~~~很多读者在看完百万 TCP 连接的系列文章之后，反馈问我有没有测试源码。也想亲自动手做出来体验...
最全Jmeter 性能 —— 模拟百万高并发压测思路！_百万级并发压测(1)，2024年最新阿里P8面试官都说太详细了
最新发布
2401_84563354的博客
05-11 473
【4G*4核配置】1台 --> 性能指标 – 推导 --只需要1台与服务器相同配置的机器能完成5000/s并发量即可（类似数学中的同理可得，以此类推）生产环境面临并发量100000，服务器20台，平均到每台服务器5000/s，当并发需求=5000/s的时候，并发量要大于等于5000/s才扛得住。先做压力测试再做负载测试，主要是因为要做压力测试你首先要知道极限并发是多少，负载测试就能知道极限并发。1秒就有1个线程就可以造成10并发的压力，所以只需要500个用户，1秒就能达到5000并发的压力。
百万并发服务器
qq_36472482的博客
02-13 105
百万并发服务器
Jmeter 性能 —— 模拟百万高并发压测思路！
MJH827的博客
01-02 395
【4G*4核配置】1台 --> 性能指标 -- 推导 --只需要1台与服务器相同配置的机器能完成5000/s并发量即可（类似数学中的同理可得，以此类推）生产环境面临并发量100000，服务器20台，平均到每台服务器5000/s，当并发需求=5000/s的时候，并发量要大于等于5000/s才扛得住。1秒就有1个线程就可以造成10并发的压力，所以只需要500个用户，1秒就能达到5000并发的压力。②基准测试 -- 少量的请求，少量服务器 -- 性能测试 -- 通过理论推导 生产环境性能。
Jmeter测试网站并发量
ClearLoveQ的博客
09-14 2540
转载自：https://www.cnblogs.com/qqbook/p/7705483.html 如何测试一个网站的性能（并发数）？ JMeter网站并发性测试 Apache JMeter是Apache组织开发的基于Java的压力测试工具。用于对软件做压力测试，它最初被设计用于Web应用测试但后来扩展到其他测试领域。 它可以用于测试静态和动态资源例如静态文件、Java小服务程序、CGI脚本、Java 对象、数据库， FTP服务器, 等等。JMeter 可以用于对服务器、网络或对象模拟巨大的负载，来在
Python aiohttp百万并发极限测试实例分析
09-18
测试百万并发极限时，我们需要考虑的主要问题包括： 1. **事件循环管理**：正确地将任务添加到事件循环，并确保所有的异步操作都在事件循环中执行。 2. **资源管理**：如上所述，`ClientSession`需要正确关闭，避免...
测试服务器的最大并发的连接数.doc
09-12
为了进一步挑战服务器的极限，计划对程序进行调整，减小线程栈空间，增加线程数量，并让测试运行一整夜，以观察服务器是否能支持5万到6万的并发连接。这种长时间的稳定性测试对于评估服务器的性能边界和优化策略至关...
内网并发测试工具
07-24
1. **系统性能**：通过模拟多个并发用户，我们可以测试服务器在处理大量请求时的响应速度和处理能力，评估系统在高并发场景下的性能瓶颈。 2. **稳定性**：长时间的高并发测试可以检测系统的稳定性和持久性，看是否...
并发测试工具
12-10
在进行并发测试时，要注意合理设置并发用户数，避免因过高的负载导致服务器崩溃。同时，通过监控服务器资源（CPU、内存、磁盘I/O等），可以评估系统的承受能力。如果发现性能瓶颈，可以根据测试结果调整系统配置或...
内网并发测试工具.rar
05-23
并发测试是软件性能工程的关键部分，特别是在分布式系统、Web应用和数据库服务器等领域。通过模拟多个用户同时请求服务，我们可以发现潜在的性能瓶颈、线程安全问题、资源竞争以及系统崩溃等情况。内网并发测试工具...
微博短视频百万级高可用、高并发架构如何设计
03-07
如何从架构上保证流量暴涨时整体平台的稳定性?如果只是简单地通过调整服务器规模解决，流量较小时过多的服务器冗余带来成本的浪费，流量暴涨时过少的服务器又令平台服务处于崩溃的边缘。
高并发测试亲测可用
04-18
用于高并发环境测试 需安装jdk>7,无需生成秘钥打开即可使用
100W并发连接测试（转）
转些好文章，促进分享。
04-26 273
100W并发连接 [url]http://www.blogjava.net/yongboy/archive/2013/04/11/397677.html[/url] VMSTAT IOSTAT 用法 [url]http://linux.cn/article-4024-2.html[/url] Netty 长连接服务 [url]http://blog.csdn.net/...
Http服务器并发访问压力测试工具（自己方便测试而编写）新附带源码
热门推荐
宋同学的Solution
03-26 1万+
为了方便对自己的服务器进行一个简单的并发访问测试，自己coding了一个简单的http post/get 并发请求工具 环境是基于VS2010  c#  .net4框架，所以运行该exe需要设备上安装了 .net framework 4.0 才可以，安装包大约40多M 可以自己去下载一个。 资源已上传到CSDN可以进行下载，免积分的，下载地址：http://download.csdn.net/detail/songqingwei1988/7102283
dubbo是长连接还是短连接_百万级别长连接，并发测试指南
weixin_39729784的博客
11-10 549
结尾有彩蛋哟！前言都说haproxy很牛x, 可是测试的结果实在是不算满意, 越测试越失望,无论是长连接还是并发, 但是测试的流程以及工具倒是可以分享分享。也望指出不足之处。100w的长连接实在算不上太难的事情，不过对于网上关于测试方法以及测试工具的相关文章实在不甚满意，才有本文。本文有两个难点,我算不上完全解决。后端代码的性能.linux内核参数的优化.环境说明下面所有的测试机器都是基于open...
百万级别长连接，并发测试指南
weixin_33674976的博客
03-22 3095
前言 都说haproxy很牛x, 可是测试的结果实在是不算满意, 越测试越失望,无论是长连接还是并发, 但是测试的流程以及工具倒是可以分享分享。也望指出不足之处。 100w的长连接实在算不上太难的事情，不过对于网上关于测试方法以及测试工具的相关文章实在不甚满意，才有本文。 本文有两个难点,我算不上完全解决。 后端代码的性能. linux内核参数的优化. 环境说明 下面所有的测试机器都是基于op...
如何测试系统的并发量
zhaojunwei666的博客
06-19 9517
前因 博主上周刚面试了一家恒生系的公司，貌似是恒生全资子公司，叫啥**云融。反正总结就是一个字，菜。为什么博主要攻击他呢，这其实是有缘由的。 因为博主在做他家的笔试的时候，系统崩溃了，（笔试可能才几百人参加） 说实话他们的并发是真的差啊，所以博主就想着对自己的项目进行一个并发测试，下面咱们就进入正题吧。 测试环境 Jmeter4.0，1核2G的Linux服务器，Chrome。 测试步骤 下载Jmeter4.0,并且Windows+R进入命令行，利用cd指令定位到Jmeter的bin目录，运行jmeter.
如何查看服务器当前的并发访问量
老余的博客
04-14 6180
服务器访问人数可以通过命令：netstat -pnt |grep:80列出 比如此时请求服务器上一个页面，通过该命令可以查看结果，后面的ESTABLISHED表示服务器正在被访问，可以通过添加wc-l统计数量，最终命令是：netstat -pnt |grep:80|wc-l此命令可以统计服务器所有url被请求的数量 因为服务器本身占用一个连接，所以此时并发...
c++ 高性能并发服务器项目实战
09-27
总之，高性能并发服务器项目实战是一个综合性的项目，需要综合考虑多个因素，包括服务器框架的选择、优化设计、性能测试与优化、集群部署等。只有通过不断的实践和优化，才能够开发出满足高并发请求的高性能服务器。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值