Linux高并发学习---epoll单机百万并发实现

最新推荐文章于 2024-01-06 00:07:30 发布
最新推荐文章于 2024-01-06 00:07:30 发布
阅读量918 收藏 7
点赞数 1
分类专栏： Linux TCP 文章标签： linux 服务器 epoll tcp/ip c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hjlogzw/article/details/122117283
版权
Linux 同时被 2 个专栏收录
16 篇文章 3 订阅
订阅专栏
TCP
10 篇文章 0 订阅
订阅专栏

一、前情提要

在上一篇文章中（Linux高并发学习—epoll的reactor实现），已经讲述了epoll的reactor实现方式，本篇文章将沿用代码实现单机百万并发的实现。

服务端代码增加了一个TCP连接的链表，用于支持大量TCP连接；客户端代码则是循环创建socket连接。话不多说，咱直接看代码！

二、代码细节

服务端之所以能支持上百万个TCP连接，离不开五元组的支持，其中源端口开放了100个，而客户端的作为目的端口也有上万个端口能够正常使用，排列组合下就有100万以上啦！

#include <stdio.h>
#include <ctype.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/select.h>
#include <sys/poll.h>
#include <sys/epoll.h>
#include <pthread.h>

#define SERVER_PORT     9000
#define BUFFER_SIZE     1024
#define MAX_EPOLL_SIZE  512
#define MAX_LISTEN_BAGS 512

#define INIT            0
#define ACCEPT          1
#define READ            2
#define WRITE           3

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

typedef struct _event_item 
{
     int fd;
     int events;
     void *args;
     callBack rhandle;     // 读事件回调
     callBack whandle;     // 写事件回调
     
     unsigned char sendBuf[BUFFER_SIZE];
     int sendLen;
     unsigned char recvBuf[BUFFER_SIZE];
     int recvLen;
} event_item;

typedef struct _block
{
     event_item *events;
     struct _block *next;
}event_block;

typedef struct _reactor
{
     int epollfd;
     int blockCnt;
     event_block *blk;       // 链表，用于存储百万TCP连接
}reactor;

int acceptCB(int fd, int events, void* args);
int readCB(int fd, int events, void* args);
int writeCB(int fd, int events, void* args);
int init_reactor(reactor *r);

reactor *instance = NULL;
reactor *getInstance(){
     if(instance == NULL){
          instance = (reactor*)malloc(sizeof(reactor));
          if(instance == NULL) 
               return NULL;
          memset(instance, 0, sizeof(reactor));
          if(init_reactor(instance) < 0){
               free(instance);
               return NULL;
          }
     }

     return instance;
}

int init_socket(short port){
     int reuseAddr = 1;
     int reusePort = 1;
     int fd = socket(AF_INET, SOCK_STREAM, 0);
     if(fd < 0)
     {
          printf("errno: %s, socket() failed!\n", strerror(errno));
          return -1;
     }
     if(fcntl(fd, F_SETFL, O_NONBLOCK) < 0){
          printf("errno: %s, fcntl() failed!\n", strerror(errno));
          return -1;
     }

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

     setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, (const void*)&reusePort, sizeof(reusePort));
     setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const void*)&reuseAddr, sizeof(reuseAddr));
     if(bind(fd, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) < 0){
          printf("errno: %s, bind() failed!\n", strerror(errno));
          return -1;
     }

     if(listen(fd, MAX_LISTEN_BAGS) < 0){
          printf("errno: %s, listen() failed!\n", strerror(errno));
          return -1;
     }

     return fd; 
}

int block_alloc(){
     reactor *r = getInstance();
     if(r == NULL){
          printf("block_alloc(): getInstance() failed!\n");
          return -1;
     }
     if(r->blk == NULL){
          printf("r->blk == NULL!\n");
          return -1;
     }

     event_item *ev = (event_item*)malloc((MAX_EPOLL_SIZE) * sizeof(event_item));
     if(ev == NULL){
          printf("block_alloc(): malloc() failed!\n");
          return -1;
     }
     memset(ev, 0, (MAX_EPOLL_SIZE) * sizeof(event_item));

     event_block *blk = (event_block*)malloc(sizeof(event_block));
     if(blk == NULL){
          printf("block_alloc(): malloc() failed!\n");
          return -1;
     }

     blk->events = ev;
     blk->next = NULL;

     event_block *p = r->blk;
     while(p->next){
          p = p->next;
     }
     p->next = blk;
     r->blockCnt ++;

     return 0;
}

int init_reactor(reactor *r){
     if(r == NULL)  return -1;
     
     memset(r, 0, sizeof(reactor));
     r->epollfd = epoll_create(1);
     if(r->epollfd <= 0){
          printf("errno: %s, epoll_create() failed!\n", strerror(errno));
          return -1;
     }

     event_block *blk = (event_block*)malloc(sizeof(event_block));
     if(blk == NULL){
          printf("init_reactor() malloc failed!\n");
          return -1;
     }
     event_item *item = (event_item*)malloc((MAX_EPOLL_SIZE) * sizeof(event_item));
     if(item == NULL){
          printf("init_reactor() malloc failed!\n");
          return -1;
     }
     memset(item, 0, (MAX_EPOLL_SIZE) * sizeof(event_item));

     blk->events = item;
     blk->next = NULL;
     r->blk = blk;
     r->blockCnt = 1;

     return 0;
}

// 根据提供的fd从链表中查询对应的event_item结构
event_item *find_events(int fd){
     reactor *r = getInstance();
     if(r == NULL){
          printf("find_events(): getInstance() failed!\n");
          return NULL;
     }

     int blkidx = fd / MAX_EPOLL_SIZE;
     while(blkidx >= r->blockCnt){   // 要查询的fd大于目前的容量，需要扩容
          block_alloc();
     }

     event_block *cur = r->blk;
     int cnt = 0;
     while(cnt++ < blkidx && cur != NULL){
          cur = cur->next;
     }
     return &(cur->events[fd % MAX_EPOLL_SIZE]);
}

int destory_reactor(){
     reactor *r = getInstance();
     if(r == NULL){
          printf("destory_reactor(): getInstance() failed!\n");
          return -1;
     }

     close(r->epollfd);
     event_block *cur = r->blk;
     event_block *nxt = NULL;
     while(cur != NULL){
          nxt = cur->next;
          free(cur->events);
          free(cur);
          cur = nxt->next;
     }

     return 0;
}

int del_reactor_events(int fd){
     reactor *r = getInstance();
     if(r == NULL){
          printf("del_reactor_events(): getInstance() failed!\n");
          return -1;
     }

     struct epoll_event ev;
     ev.data.ptr = NULL;
     epoll_ctl(r->epollfd, EPOLL_CTL_DEL, fd, &ev);
     
     return 0;
}

int set_reactor_events(int fd, int event, void *args){
     struct epoll_event ev;
     event_item *item = find_events(fd);
     reactor *r = getInstance();
     if(r == NULL){
          printf("set_reactor_events(): getInstance() failed!\n");
          return -1;
     }

     if(event == ACCEPT){
          item->fd = fd;
          item->args = args;
          item->rhandle = acceptCB;
          ev.events = EPOLLIN;
     }else if(event == READ){
          item->fd = fd;
          item->args = args;
          item->rhandle = readCB;
          ev.events = EPOLLIN;
          // ev.events |= EPOLLET;
     }else if(event == WRITE){
          item->fd = fd;
          item->args = args;
          item->whandle = writeCB;
          ev.events = EPOLLOUT;
     }

     ev.data.ptr = item;
     if(item->events == INIT){
          epoll_ctl(r->epollfd, EPOLL_CTL_ADD, fd, &ev);
          item->events = event;
     }else if(item->events != event){
          epoll_ctl(r->epollfd, EPOLL_CTL_MOD, fd, &ev);
          item->events = event;
     }

     return 0;
}

int acceptCB(int fd, int events, void* args){
     struct sockaddr_in clientAdr;
     socklen_t len = sizeof(clientAdr);
     int connfd = accept(fd, (struct sockaddr*)&clientAdr, &len);
     if(fcntl(connfd, F_SETFL, O_NONBLOCK) < 0){
          printf("errno: %s, fcntl() failed!\n", strerror(errno));
          return -1;
     }
     printf("new connection: %d\n", connfd);
     set_reactor_events(connfd, READ, args);

     return 0;
}

int readCB(int fd, int events, void* args){
     reactor *r = getInstance();
     if(r == NULL){
          printf("readCB(): getInstance() failed!\n");
          return -1;
     }

     event_item *item = find_events(fd);
     unsigned char *rbuf = item->recvBuf;

     int n = recv(fd, rbuf, BUFFER_SIZE, 0);
     if(n == 0){
          printf("errno: %s, clientfd %d closed!\n", strerror(errno), fd);
          del_reactor_events(fd);
          close(fd);
          return -1;
     }else if(n < 0){
          if(errno != EINTR && errno != EWOULDBLOCK && errno != EAGAIN){
               printf("errno: %s, error!\n", strerror(errno));
               del_reactor_events(fd);
               close(fd);
               return -1;
          }
     }
     else{
          unsigned char *sbuf = item->sendBuf;
          memcpy(sbuf, rbuf, n);
          item->sendLen = n;
          printf("recv from fd = %d: %s\n", fd, sbuf);
          set_reactor_events(fd, WRITE, args);
     }

     return 0;
}

int writeCB(int fd, int events, void* args){
     reactor *r = getInstance();
     if(r == NULL){
          printf("reactor_loop(): getInstance() failed!\n");
          return -1;
     }

     event_item *item = find_events(fd);
     unsigned char *sbuf = item->sendBuf;
     int len = item->sendLen;

     int ret = send(fd, sbuf, len, 0);
     if(ret < len){
          if(ret == 0){
               del_reactor_events(fd);
               close(fd);
          }
          set_reactor_events(fd, WRITE, args);
     }else{
          set_reactor_events(fd, READ, args);
     }
     return 0;
}

int reactor_loop(){
     struct epoll_event events[MAX_EPOLL_SIZE] = {0};
     reactor *r = getInstance();
     if(r == NULL){
          printf("reactor_loop(): getInstance() failed!\n");
          return -1;
     }

     while(1){
          int nready = epoll_wait(r->epollfd, events, MAX_EPOLL_SIZE, -1);
          if(nready == -1)    
               continue;
          for(int i = 0; i < nready; ++i){
               event_item *item = (event_item *)events[i].data.ptr;
               if(events[i].events & EPOLLIN)
                    (*item->rhandle)(item->fd, 0, NULL);
               if(events[i].events & EPOLLOUT)
                    (*item->whandle)(item->fd, 0, NULL);
          }         
     }

     return 0;
}

int main(int argc, char *argv[])
{
     int sockfd = 0;
     int port = SERVER_PORT;

     for (int i = port; i < port + 100; i++)
     {
          sockfd = init_socket(i);
          if(sockfd < 0)  
               return -1;
          set_reactor_events(sockfd, ACCEPT, NULL);
     }
     // sockfd = init_socket(SERVER_PORT);
     // if(sockfd < 0)  
     //      return -1;
     // set_reactor_events(sockfd, ACCEPT, NULL);

     reactor_loop();

     return 0;
}

客户端的代码则很简单了，一直循环创建连接就OK了，如下：



#include <stdio.h>
#include <string.h>
#include <stdlib.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>


#define MAX_BUFFER		128
#define MAX_EPOLLSIZE	(512*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 < 512000 && !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 >= 512000) {
			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(500);
	}

	return 0;

err:
	printf("error : %s\n", strerror(errno));
	return 0;
	
}

三、系统配置

只写代码当然还不够，我们需要修改Linux内核参数才行哈！

1、首先我们需要单个进程支持的文件描述符fd的个数：
使用 ulimit -n 1048576，可临时更改，生效范围为当前会话
永久修改的方法：

vim /etc/security/limits.conf
添加：
soft nofile 1048576
hard nofile 1048576

再修改所有进程支持的文件描述符个数：

echo 1048576 > /proc/sys/fs/file-max

2、修改Linux内核协议栈的相关参数

echo 786432 2097152 3145728 > /proc/sys/net/ipv4/tcp_mem
echo 4096 4096 16777216 > /proc/sys/net/ipv4/tcp_rmem
echo 4096 4096 16777216 > /proc/sys/net/ipv4/tcp_wmem
echo 16384 > /proc/sys/net/ipv4/tcp_max_orphans
echo 1048576> /proc/sys/net/nf_conntrack_max
echo 1200> /proc/sys/net/netfilter/nf_conntrack_tcp_timeout_established

修改完之后，可以使用sysctl -a 查看内核参数是否已经改变了！
关于这些参数的含义我给出下面一些参考链接：
《关于高负载服务器Kernel的TCP参数优化》
《百万并发之 tcp_mem》

四、并发测试

设置完参数之后，我们准备三个虚拟机，一个作为服务端，其他作为客户端，客户端代码会一直创建socket连接到512000个连接，两个客户端一共创建1024000个连接。
其中服务端虚拟机内存是6个G，客户端虚拟机内存为2个G。
允许情况如下：
在这里插入图片描述
由于我是在一台笔记本上进行的测试，在连接达到90w+的时候，内存已经爆满（无奈摊手），只能强行kill掉进程了！
在这里插入图片描述

五、后续

本篇文章关于单线程百万并发的测试就告一段落了，代码中还有挺多不足的哈，欢迎各位同学提出哈！

阿杰的小鱼塘
关注
专栏目录
C 语言网络编程 — 高并发 TCP 网络服务器
烟云的计算
03-09 1315
可见，I/O 多路复用模型大大增加了每个进程可以管理的 Socket 数量，直到操作系统 fd 最大数量限制为止，通常可以设置百万级别，即：单机单进程支持百万连接，epoll 是解决 C10K 的利器，很多开源软件用到了它。四次挥手是一个冗长的过程，由于网络环境的复杂性与 TCP 连接的可靠性相违背，所以在某些特殊的场景中会出现相应的问题。所以，实际上，close() 并不会马上断开 Socket Connection，在高性能网络服务器中，需要非常关注 TCP 连接的状态情况。
epoll实现tcp百万级高并发测试源码
12-06
https://blog.csdn.net/u014220105/article/details/84849570 可先参考相关描述，epoll实现tcp百万级高并发测试，代码仅用于测试和功能验证，并不是特别完善，不喜勿喷，欢迎指导
2.2.1使用epoll及reactor实现服务器百万并发
weixin_56220992的博客
10-15 513
使用epoll以及reactor实现服务器百万并发
基于EPOLL的反应堆的百万服务器并发实现
m0_56375727的博客
03-25 205
每一个模块里包含一个block，每个block属于一个结构体数组，这个数组的最大存储的数量为1024,这样我们就可以控制百万级别以上的连接。不能，因为初始化的时候EPOLLOUT是监听写缓冲区的，由于刚开始的缓冲区是空的，这个缓冲区就会可写，一直被触发！当listenfd面对大量的数据的时候，为了避免漏掉连接，我们需要用到水平触发。对于反应堆的结构，主要的是回调函数的设置，而回调函数在结构体数组上能够存储，具体如下图。因为在边缘触发的情况下，一旦有连接或者其他读的事件，就会触发事件的发生。
Linux下高并发socket，单机提供五十万连接
Linux C/C++后台开发
07-14 4871
引用《Linux网络编程》 一个完整的Socket描述，五元组，{协议，本地地址，本地端口，远程地址，远程端口} 当我们自己写客户端测试程序来测试我们的服务端程序性能的时候，经常会遇到连接量上不去的问题，大多都是停留在2万左右。如果我们的测试机器有限，要想达到百万连接量的测试，那我们哪里去找50台测试机器了？实际的测试也不可能给50台测试机器。那么根据这个五元组，我们可以做一下文章。首先协议已
epoll服务器百万并发测试
最新发布
weixin_73240939的博客
01-06 1274
服务器百万并发是指能够承载的客户端的数量，也就是说可以承接100w个客户端的连接。
易语言-hp-socket Agent模型，单机6w+并发连接数 tcp 压测
06-26
4. **事件驱动编程**：结合事件驱动模型（如epoll在Linux中的实现），通过注册事件回调函数，只处理准备就绪的连接，减少上下文切换次数。 5. **负载均衡**：如果服务器集群中有多台机器，可以使用负载均衡策略，将...
nginx文件服务器5万并发量,Nginx服务器高性能优化-轻松实现10万并发访问量
weixin_30284125的博客
08-06 2840
今天要说的是Nginx服务器高性能优化的配置，如何使Nginx轻松实现10万并发访问量。通常来说，一个正常的 Nginx Linux 服务器可以达到 500,000 – 600,000 次/秒 的请求处理性能，如果Nginx服务器经过优化的话，则可以稳定地达到 904,000 次/秒 的处理性能，大大提高Nginx的并发访问量。这里需要特别说明的是：1、本文中所有列出来的配置都是在我的测试环境验证...
单机高并发模型设计
l688899886的博客
07-08 309
在微服务架构下，我们习惯使用多机器、分布式存储、缓存去支持一个高并发的请求模型，而忽略了单机高并发模型是如何工作的。这篇文章通过结构客户端与服务端的建立连接和数据传输过程，阐述下如何进行单机高并发模型设计。如何在一台物理机上同时服务10K用户，及10000个用户，对于java程序员来说，这不是什么难事，使用netty就能构建出支持并发超过10000的服务端程序。那么netty是如何实现的？首先我们忘掉netty，从头开始分析。每个用户一个连接，对于服务端就是两件事我们以常见TCP连接为例。 一张很熟悉的图。
Netty如何做到单机百万并发？
q66562636的博客
08-31 745
说到石中剑 Netty，我们知道他极其强悍的性能以及纯异步模型，释放出了极强的生产力，内置的各种编解码编排，心跳包检测，粘包拆包处理等，高效且易于使用，以至于很多耳熟能详的组件都在使用，比如 Hadoop，Dubbo 等。同时也有一个 inode table，里面则记录的是底层的文件描述符信息。但是需要注意的是，当有成千上万个客户端连接上来开始进行数据发送，由于 LT 的特性，内核会频繁的处理通知操作，导致其相对于 ET 来说，比较的耗费系统资源，所以，随着客户端的增多，其性能也就越差。...
Linux + C + Epoll实现高并发服务器(线程池 + 数据库连接池)
09-27
在Linux 系统下面用C 语言实现的高并发服务器的代码，具体用到了Epoll，线程池，数据库连接池。 具体可以看下连接http://blog.csdn.net/wuyuxing24/article/details/48758927
一文读懂 Linux 下单机实现百万并发的内核黑科技：连接跟踪（Conntrack）
easylife206的专栏
02-01 1270
公众号关注「奇妙的 Linux 世界」设为「星标」，每天带你玩转 Linux ！本文介绍连接跟踪（connection tracking，conntrack，CT）的原理，应用，及其在...
linux c++ 利用epoll实现百万并发服务器
hw5230的博客
04-21 434
该代码实现了一个简单的echo服务，监听8080端口并回显客户端发送的数据。在每个连接上采用非阻塞Socket，使用epoll模型进行IO复用。同时，通过设置事件为EPOLLET，实现边沿触发模式，避免因为水平触发模式下的重复通知而导致资源浪费。在Linux环境下，通常建议使用多线程并发模型，因为线程之间的切换开销比进程小。使用一个高效的IO复用机制来处理大量连接请求。在Linux环境下，最常用的IO复用机制是epoll。优化代码实现，如减少锁的使用、避免内存泄漏等。
linux服务器实现百万并发
effort_study的博客
07-19 2293
并发量和承载的概念 并发量：一个服务器能同时承载客户端的数量 承载：客户端发送给服务器的请求(http或tcp等)在200ms内可以返回正确的结果 影响并发量的主要因素 数据库响应速度 网络带宽响应 内存操作 日志性能 服务器能同时建立的连接数量只是并发的基础，服务器处理客户端的请求包括请求、响应、处理和关闭。 网络五元组 源ip 目的ip 源端口号 目的端口号 协议 ​ 由于只有一台客户端不断建立连接，所以源ip是一样的；目的ip也只有一台服务器；源端口号是不确定的，由操作系统或自己指定，目的端
高并发的epoll+线程池，epoll在线程池内
热门推荐
LH806732的专栏
09-19 1万+
转载自：http://blog.chinaunix.net/uid-311680-id-2439723.html epoll是linux下高并发服务器的完美方案，因为是基于事件触发的，所以比select快的不只是一个数量级。 单线程epoll，触发量可达到15000，但是加上业务后，因为大多数业务都与数据库打交道，所以就会存在阻塞的情况，这个时候就必须用多线程来提速。   ep
Linux的TCP连接数量最大不能超过65535？那服务器是如何应对百万千万的并发的？...
芋艿V
03-16 351
点击上方“芋道源码”，选择“设为星标”管她前浪，还是后浪？能浪的浪，才是好浪！每天 10:33更新文章，每天掉亿点点头发...源码精品专栏原创 | Java 2021超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网络应用框架 Netty 源码解析消息中间件 RocketMQ 源码解析数据库中间件 Sharding-JDBC 和 MyCAT 源码解析作业调度中间件 E...
【Linux网络编程】高并发服务器 socket+epoll封装 服务器/客户端举例
持续学习，持续进步！
06-29 3951
本文主要介绍高并发服务器设计，socke+epoll封装，以及相关代码示例说明
linux的TCP连接数量最大不能超过65535个吗，那服务器是如何应对百万千万的并发的？...
emprere的博客
06-25 953
点击关注公众号：互联网架构师，后台回复2T获取2TB学习资源！上一篇：Alibaba开源内网高并发编程手册.pdf作者：前浪浪奔浪流链接：https://www.jianshu.com/p/f070212024a1最大并发tcp连接数是多少呢？首先，问题中描述的65535个连接指的是客户端连接数的限制。在tcp应用中，server事先在某个固定端口监听，client主动...
Linux/C epoll实现tcp并发服务器
weixin_40582626的博客
10-19 1238
epoll是poll的改进,同时I/O多路复用,相较select: select: 当网卡收到数据之后,将数据写入缓冲区,并发送中断给cpu.cpu接收中断并将数据从内核态复制到socket的缓冲区.唤醒socket进程,同时从socket的等待队列中移除这个进程引用. 1.select,需要遍历socket列表,频繁的对等待队列进行添加移除操作, 2.数据到达后还需要给变量所有socket才能获知哪些socket有数据 用户处理select返回，需要遍历bitmap，才能知道哪一个IO被置位，这
Linux高并发处理：epoll与MySQL连接池技术解析
资源摘要信息: "本资源涉及Linux高并发技术、epoll机制、MySQL连接池技术，以及相关的epoll工具和MySQL工具的使用，主要面向TCP/IP网络编程的深入应用。" 在Linux操作系统中，高并发是一种常见的系统设计需求，尤其...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿杰的小鱼塘

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值