（4.5）监听端口实战、epoll介绍及原理详析

最新推荐文章于 2023-08-02 16:26:00 发布
最新推荐文章于 2023-08-02 16:26:00 发布
阅读量1.2k 收藏 6
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34863439/article/details/88378902
版权

一：监听端口

（1.1）开启监听端口

  

 

二：epoll技术简介 

//（2.1）epoll概述


    //(1)I/O多路复用：epoll就是一种典型的I/O多路复用技术:epoll技术的最大特点是支持高并发；
     //传统多路复用技术select,poll，在并发量达到1000-2000，性能就会明显下降；
     //epoll,kquene(freebsd)
     //epoll，从linux内核2.6引入的，2.6之前是没有的；


    //(2)epoll和kquene技术类似：单独一台计算机支撑少则数万，多则数十上百万并发连接的核心技术；
    //epoll技术完全没有这种性能会随着并发量提高而出现明显下降的问题。但是并发没增加一个，必定要消耗一定的内存去保存这个连接相关的数据；
     //并发量总还是有限制的，不可能是无限的；


    //(3)10万个连接同一时刻，可能只有几十上百个客户端给你发送数据，epoll只处理这几十上百个客户端；


    //(4)很多服务器程序用多进程，每一个进程对应一个连接；也有用多线程做的，每一个线程对应 一个连接；
    //epoll事件驱动机制，在单独的进程或者单独的线程里运行，收集/处理事件；没有进程/线程之间切换的消耗，高效


    //(5)适合高并发，融合epoll技术到项目中，作为大家将来从事服务器开发工作的立身之本；
    //写小demo非常简单，难度只有1-10，但是要把epoll技术融合到商业的环境中，那么难度就会骤然增加10倍；

 

 

三：epoll原理与函数介绍：三个函数

//（3.1）课件介绍

    课件地址
    //a)c1000k_test这里，测试百万并发的一些测试程序；一般以main();
    //b)ntytcp：nty_epoll_inner.h，nty_epoll_rb.c
          //epoll_create();
          //epoll_ctl();
          //epoll_wait();
          //epoll_event_callback();  

 

//（3.2）epoll_create()函数


 //格式：int epoll_create(int size);
 //功能：创建一个epoll对象，返回该对象的描述符【文件描述符】，这个描述符就代表这个epoll对象，后续会用到；
 //这个epoll对象最终要用close(),因为文件描述符/句柄 总是关闭的；
 //size: >0;

 


    //原理：
    //a)struct eventpoll *ep = (struct eventpoll*)calloc(1, sizeof(struct eventpoll)); 
    //b)rbr结构成员：代表一颗红黑树的根节点[刚开始指向空],把rbr理解成红黑树的根节点的指针；
       //红黑树，用来保存  键【数字】/值【结构】，能够快速的通过你给key，把整个的键/值取出来；
    //c)rdlist结构成员：代表 一个双向链表的表头指针；
       //双向链表：从头访问/遍历每个元素特别快；next。
    //d)总结：创建了一个eventpoll结构对象，被系统保存起来；
       //rbr成员被初始化成指向一颗红黑树的根【有了一个红黑树】；
       //rdlist成员被初始化成指向一个双向链表的根【有了双向链表】；


//创建epoll对象，创建一颗空红黑树，一个空双向链表
int epoll_create(int size) {

	if (size <= 0) return -1;

	nty_tcp_manager *tcp = nty_get_tcp_manager();
	if (!tcp) return -1;
	
	struct _nty_socket *epsocket = nty_socket_allocate(NTY_TCP_SOCK_EPOLL);
	if (epsocket == NULL) {
		nty_trace_epoll("malloc failed\n");
		return -1;
	}

	//(1)相当于new了一个eventpoll对象【开辟了一块内存】
	struct eventpoll *ep = (struct eventpoll*)calloc(1, sizeof(struct eventpoll)); //参数1：元素数量 ，参数2：每个元素大小
	if (!ep) {
		nty_free_socket(epsocket->id, 0);
		return -1;
	}

	ep->rbcnt = 0;

	//(2)让红黑树根节点指向一个空
	RB_INIT(&ep->rbr);       //等价于ep->rbr.rbh_root = NULL;

	//(3)让双向链表的根节点指向一个空
	LIST_INIT(&ep->rdlist);  //等价于ep->rdlist.lh_first = NULL;

	if (pthread_mutex_init(&ep->mtx, NULL)) {
		free(ep);
		nty_free_socket(epsocket->id, 0);
		return -2;
	}

	if (pthread_mutex_init(&ep->cdmtx, NULL)) {
		pthread_mutex_destroy(&ep->mtx);
		free(ep);
		nty_free_socket(epsocket->id, 0);
		return -2;
	}

	if (pthread_cond_init(&ep->cond, NULL)) {
		pthread_mutex_destroy(&ep->cdmtx);
		pthread_mutex_destroy(&ep->mtx);
		free(ep);
		nty_free_socket(epsocket->id, 0);
		return -2;
	}

	if (pthread_spin_init(&ep->lock, PTHREAD_PROCESS_SHARED)) {
		pthread_cond_destroy(&ep->cond);
		pthread_mutex_destroy(&ep->cdmtx);
		pthread_mutex_destroy(&ep->mtx);
		free(ep);

		nty_free_socket(epsocket->id, 0);
		return -2;
	}

	tcp->ep = (void*)ep;
	epsocket->ep = (void*)ep;

	return epsocket->id;
}

 

 

//（3.3）epoll_ctl()函数


    //格式：int epoll_ctl(int efpd,int op,int sockid,struct epoll_event *event);


    //功能：把一个socket以及这个socket相关的事件添加到这个epoll对象描述符中去，目的就是通过这个epoll对象来监视                     这 个socket【客户端的TCP连接】上数据的来往情况;
                 //当有数据来往时，系统会通知我们；  
                 //我们把感兴趣的事件通过epoll_ctl（）添加到系统，当这些事件来的时候，系统会通知我们；


    //efpd：epoll_create()返回的epoll对象描述符；
    //op：   动作，添加/删除/修改 ，对应数字是1,2,3， EPOLL_CTL_ADD, EPOLL_CTL_DEL ,EPOLL_CTL_MOD
         //EPOLL_CTL_ADD添加事件：等于你往红黑树上添加一个节点，每个客户端连入服务器后，服务器都会产生 一个                                                               对应的socket，每个连接这个socket值都不重复
                                                          //所以，这个socket就是红黑树中的key，把这个节点添加到红黑树上去；
         //EPOLL_CTL_MOD：修改事件；你 用了EPOLL_CTL_ADD把节点添加到红黑树上之后，才存在修改；
         //EPOLL_CTL_DEL： 是从红黑树上把这个节点干掉；这会导致这个socket【这个tcp链接】上无法收到任何系统通                                                 知事件；
    //sockid：表示客户端连接，就是你从accept()；这个是红黑树里边的key;
    //event： 事件信息，这里包括的是 一些事件信息；EPOLL_CTL_ADD和EPOLL_CTL_MOD都要用到这个event参数里                       边 的事件信息；


    //原理：
    //a)epi = (struct epitem*)calloc(1, sizeof(struct epitem));


    //b)epi = RB_INSERT(_epoll_rb_socket, &ep->rbr, epi);    【EPOLL_CTL_ADD】 增加节点到红黑树中
         //epitem.rbn ，代表三个指针，分别指向红黑树的左子树，右子树，父亲；
         //epi = RB_REMOVE(_epoll_rb_socket, &ep->rbr, epi);【EPOLL_CTL_DEL】，从红黑树中把节点干掉
                                                                                                【EPOLL_CTL_MOD】，找到红黑树节点，修改节点内容；

    //红黑树的节点是epoll_ctl[EPOLL_CTL_ADD]往里增加的节点；面试可能考
    //红黑树的节点是epoll_ctl[EPOLL_CTL_DEL]删除的；


    //总结：
    //EPOLL_CTL_ADD： 等价于往红黑树中增加节点
    //EPOLL_CTL_DEL： 等价于从红黑树中删除节点
    //EPOLL_CTL_MOD：等价于修改已有的红黑树的节点

   

//往红黑树中加每个tcp连接以及相关的事件
int epoll_ctl(int epid, int op, int sockid, struct epoll_event *event) {

	nty_tcp_manager *tcp = nty_get_tcp_manager();
	if (!tcp) return -1;

	nty_trace_epoll(" epoll_ctl --> 1111111:%d, sockid:%d\n", epid, sockid);
	struct _nty_socket *epsocket = tcp->fdtable->sockfds[epid];
	//struct _nty_socket *socket = tcp->fdtable->sockfds[sockid];

	//nty_trace_epoll(" epoll_ctl --> 1111111:%d, sockid:%d\n", epsocket->id, sockid);
	if (epsocket->socktype == NTY_TCP_SOCK_UNUSED) {
		errno = -EBADF;
		return -1;
	}

	if (epsocket->socktype != NTY_TCP_SOCK_EPOLL) {
		errno = -EINVAL;
		return -1;
	}

	nty_trace_epoll(" epoll_ctl --> eventpoll\n");

	struct eventpoll *ep = (struct eventpoll*)epsocket->ep;
	if (!ep || (!event && op != EPOLL_CTL_DEL)) {
		errno = -EINVAL;
		return -1;
	}

	if (op == EPOLL_CTL_ADD) {
		//添加sockfd上关联的事件
		pthread_mutex_lock(&ep->mtx);

		struct epitem tmp;
		tmp.sockfd = sockid;
		struct epitem *epi = RB_FIND(_epoll_rb_socket, &ep->rbr, &tmp); //先在红黑树上找，根据key来找，也就是这个sockid，找的速度会非常快
		if (epi) {
			//原来有这个节点，不能再次插入
			nty_trace_epoll("rbtree is exist\n");
			pthread_mutex_unlock(&ep->mtx);
			return -1;
		}

		//只有红黑树上没有该节点【没有用过EPOLL_CTL_ADD的tcp连接才能走到这里】；

		//(1)生成了一个epitem对象，大家注意这个结构epitem，这个结构对象，其实就是红黑的一个节点，也就是说，红黑树的每个节点都是 一个epitem对象；
		epi = (struct epitem*)calloc(1, sizeof(struct epitem));
		if (!epi) {
			pthread_mutex_unlock(&ep->mtx);
			errno = -ENOMEM;
			return -1;
		}
		
		//(2)把socket(TCP连接)保存到节点中；
		epi->sockfd = sockid;  //作为红黑树节点的key，保存在红黑树中

		//(3)我们要增加的事件也保存到节点中；
		memcpy(&epi->event, event, sizeof(struct epoll_event));

		//(4)把这个节点插入到红黑树中去
		epi = RB_INSERT(_epoll_rb_socket, &ep->rbr, epi); //实际上这个时候epi的rbn成员就会发挥作用，如果这个红黑树中有多个节点，那么RB_INSERT就会epi->rbi相应的值：可以参考图来理解
		assert(epi == NULL);
		ep->rbcnt ++;
		
		pthread_mutex_unlock(&ep->mtx);

	} else if (op == EPOLL_CTL_DEL) {
		//把红黑树节点从红黑树上删除
		pthread_mutex_lock(&ep->mtx);

		struct epitem tmp;
		tmp.sockfd = sockid;
		
		struct epitem *epi = RB_FIND(_epoll_rb_socket, &ep->rbr, &tmp);//先在红黑树上找，根据key来找，也就是这个sockid，找的速度会非常快
		if (!epi) {
			nty_trace_epoll("rbtree no exist\n");
			pthread_mutex_unlock(&ep->mtx);
			return -1;
		}
		
		//只有在红黑树上找到该节点【用过EPOLL_CTL_ADD的tcp连接才能走到这里】；

		//(1)从红黑树上把这个节点干掉
		epi = RB_REMOVE(_epoll_rb_socket, &ep->rbr, epi);
		if (!epi) {
			nty_trace_epoll("rbtree is no exist\n");
			pthread_mutex_unlock(&ep->mtx);
			return -1;
		}

		ep->rbcnt --;
		free(epi);
		
		pthread_mutex_unlock(&ep->mtx);

	} else if (op == EPOLL_CTL_MOD) {
		//修改红黑树某个节点的内容
		struct epitem tmp;
		tmp.sockfd = sockid;
		struct epitem *epi = RB_FIND(_epoll_rb_socket, &ep->rbr, &tmp); //先在红黑树上找，根据key来找，也就是这个sockid，找的速度会非常快
		if (epi) {
			//(1)红黑树上有该节点，则修改对应的事件
			epi->event.events = event->events;
			epi->event.events |= EPOLLERR | EPOLLHUP;
		} else {
			errno = -ENOENT;
			return -1;
		}

	} else {
		nty_trace_epoll("op is no exist\n");
		assert(0);
	}

	return 0;
}

 

 //当事件发生，我们如何拿到操作系统的通知；

//（3.4）epoll_wait()函数


    //格式：int epoll_wait(int epfd,struct epoll_event *events,int maxevents,int timeout);


    //功能：阻塞一小段时间并等待事件发生，返回事件集合，也就是获取内核的事件通知；
                  //说白了就是遍历这个双向链表，把这个双向链表里边的节点数据拷贝出去，拷贝完毕的就从双向链表里移除；
                  //因为双向链表里记录的是所有有数据/有事件的socket【TCP连接】；


    //参数epfd：是epoll_create()返回的epoll对象描述符；
    //参数events：是内存，也是数组，长度 是maxevents，表示此次epoll_wait调用可以收集到的maxevents个已经继续                                【已经准备好的】的读写事件；
                            //说白了，就是返回的是 实际 发生事件的tcp连接数目；
    //参数timeout：阻塞等待的时长；


 //epitem结构设计的高明之处：既能够作为红黑树中的节点，又能够作为双向链表中的节点；

 

//到双向链表中去取相关的事件通知
int epoll_wait(int epid, struct epoll_event *events, int maxevents, int timeout) {

	nty_tcp_manager *tcp = nty_get_tcp_manager();
	if (!tcp) return -1;

	//nty_socket_map *epsocket = &tcp->smap[epid];
	struct _nty_socket *epsocket = tcp->fdtable->sockfds[epid];
	if (epsocket == NULL) return -1;

	if (epsocket->socktype == NTY_TCP_SOCK_UNUSED) {
		errno = -EBADF;
		return -1;
	}

	if (epsocket->socktype != NTY_TCP_SOCK_EPOLL) {
		errno = -EINVAL;
		return -1;
	}

	struct eventpoll *ep = (struct eventpoll*)epsocket->ep;
	if (!ep || !events || maxevents <= 0) {
		errno = -EINVAL;
		return -1;
	}

	if (pthread_mutex_lock(&ep->cdmtx)) {
		if (errno == EDEADLK) {
			nty_trace_epoll("epoll lock blocked\n");
		}
		assert(0);
	}

	//(1)这个while用来等待一定的时间【在这段时间内，发生事件的TCP连接，相关的节点，会被操作系统扔到双向链表去【当然这个节点同时也在红黑树中呢】】
	while (ep->rdnum == 0 && timeout != 0) {

		ep->waiting = 1;
		if (timeout > 0) {

			struct timespec deadline;

			clock_gettime(CLOCK_REALTIME, &deadline);
			if (timeout >= 1000) {
				int sec;
				sec = timeout / 1000;
				deadline.tv_sec += sec;
				timeout -= sec * 1000;
			}

			deadline.tv_nsec += timeout * 1000000;

			if (deadline.tv_nsec >= 1000000000) {
				deadline.tv_sec++;
				deadline.tv_nsec -= 1000000000;
			}

			int ret = pthread_cond_timedwait(&ep->cond, &ep->cdmtx, &deadline);
			if (ret && ret != ETIMEDOUT) {
				nty_trace_epoll("pthread_cond_timewait\n");
				
				pthread_mutex_unlock(&ep->cdmtx);
				
				return -1;
			}
			timeout = 0;
		} else if (timeout < 0) {

			int ret = pthread_cond_wait(&ep->cond, &ep->cdmtx);
			if (ret) {
				nty_trace_epoll("pthread_cond_wait\n");
				pthread_mutex_unlock(&ep->cdmtx);

				return -1;
			}
		}
		ep->waiting = 0; 

	}

	pthread_mutex_unlock(&ep->cdmtx);

	//等一小段时间，等时间到达后，流程来到这里。。。。。。。。。。。。。。

	pthread_spin_lock(&ep->lock);

	int cnt = 0;

	//(1)取得事件的数量
	//ep->rdnum：代表双向链表里边的节点数量（也就是有多少个TCP连接来事件了）
	//maxevents：此次调用最多可以收集到maxevents个已经就绪【已经准备好】的读写事件
	int num = (ep->rdnum > maxevents ? maxevents : ep->rdnum); //哪个数量少，就取得少的数字作为要取的事件数量
	int i = 0;
	
	while (num != 0 && !LIST_EMPTY(&ep->rdlist)) { //EPOLLET

		//(2)每次都从双向链表头取得 一个一个的节点
		struct epitem *epi = LIST_FIRST(&ep->rdlist);

		//(3)把这个节点从双向链表中删除【但这并不影响这个节点依旧在红黑树中】
		LIST_REMOVE(epi, rdlink); 

		//(4)这是个标记，标记这个节点【这个节点本身是已经在红黑树中】已经不在双向链表中；
		epi->rdy = 0;  //当这个节点被操作系统 加入到 双向链表中时，这个标记会设置为1。

		//(5)把事件标记信息拷贝出来；拷贝到提供的events参数中
		memcpy(&events[i++], &epi->event, sizeof(struct epoll_event));
		
		num --;
		cnt ++;       //拷贝 出来的 双向链表 中节点数目累加
		ep->rdnum --; //双向链表里边的节点数量减1
	}
	
	pthread_spin_unlock(&ep->lock);

	//(5)返回 实际 发生事件的 tcp连接的数目；
	return cnt; 
}

 

 

//（3.5）内核向双向链表增加节点


//一般有四种情况，会使操作系统把节点插入到双向链表中；
    //a)客户端完成三路握手；服务器要accept();
    //b)当客户端关闭连接，服务器也要调用close()关闭；
    //c)客户端发送数据来的；服务器要调用read(),recv()函数来收数据；
    //d)当可以发送数据时；服务武器可以调用send(),write()；
    //e)其他情况；写实战代码再说；

//当发生客户端三路握手连入、可读、可写、客户端断开等情况时，操作系统会调用这个函数，用以往双向链表中增加一个节点【该节点同时 也在红黑树中】
int epoll_event_callback(struct eventpoll *ep, int sockid, uint32_t event) {

	struct epitem tmp;
	tmp.sockfd = sockid;

	//(1)根据给定的key【这个TCP连接的socket】从红黑树中找到这个节点
	struct epitem *epi = RB_FIND(_epoll_rb_socket, &ep->rbr, &tmp);
	if (!epi) {
		nty_trace_epoll("rbtree not exist\n");
		assert(0);
	}

	//(2)从红黑树中找到这个节点后，判断这个节点是否已经被连入到双向链表里【判断的是rdy标志】
	if (epi->rdy) {
		//这个节点已经在双向链表里，那无非是把新发生的事件标志增加到现有的事件标志中
		epi->event.events |= event;
		return 1;
	} 

	//走到这里，表示 双向链表中并没有这个节点，那要做的就是把这个节点连入到双向链表中

	nty_trace_epoll("epoll_event_callback --> %d\n", epi->sockfd);
	
	pthread_spin_lock(&ep->lock);

	//(3)标记这个节点已经被放入双向链表中，我们刚才研究epoll_wait()的时候，从双向链表中把这个节点取走的时候，这个标志被设置回了0
	epi->rdy = 1;  

	//(4)把这个节点链入到双向链表的表头位置
	LIST_INSERT_HEAD(&ep->rdlist, epi, rdlink);

	//(5)双向链表中的节点数量加1，刚才研究epoll_wait()的时候，从双向链表中把这个节点取走的时候，这个数量减了1
	ep->rdnum ++;
	pthread_spin_unlock(&ep->lock);

	pthread_mutex_lock(&ep->cdmtx);

	pthread_cond_signal(&ep->cond);
	pthread_mutex_unlock(&ep->cdmtx);
	return 0;
}

 

 

Try1024
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
网络编程：epoll多路复用实现多客户端的监听accept和write函数的阻塞解除
qq_42343682的博客
03-31 723
epoll多路复用实现多客户端： 流程： 1、创建epoll 2、添加要监听的事件 3、监听（阻塞） 4、判断 原理图 int epoll_create(int size); 参数:监听事件个数(linux2.6.8可以忽略, 所以只需要填写一个大于0的数) _ int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event); 中文参数： int epoll_ctl(文件描述符, 事件状态， 要监听的文件描述符， 结构体) 事件状态：
epoll监听文件_epoll的 - 轮询多个文件描述符（即是插座）
weixin_42116058的博客
12-24 283
I read the man page and went through this example for usage: https://banu.com/blog/2/how-to-use-epoll-a-complete-example-in-c/, but I can't figure a way to do what I am trying to do using epoll, can a...
select及触发方式，select监听多链接，select与epoll的实现区别
weixin_30536513的博客
06-15 261
select及触发方式 触发方式：1、水平触发　2、边缘触发 触发：达到某种情况发生某种状态 心得：阻塞是等待，IO是输入输出，I/O接口 select监听多链接 IO多路复用优势：同时可以监听多个链接 str(data_byte,'utf8')　　bytes(data,'utf8') select与epoll的实现区别 select在很多系统通用，window只有sele...
基于UDP的soceket使用epoll方式监听并添加超时机制的C++代码实现
最新发布
w102934567的博客
08-02 234
在epoll_wait的循环中，等待事件发生，如果超时则进行超时处理逻辑，否则接收UDP数据并进行处理。请注意，上述示例只是一个简单的实现，对于真实场景，可能需要进行错误处理、异常情况处理等更完善的代码编写。// 超时时间设定为5秒。// 接收UDP数据并进行处理。// 处理接收到的数据。// 添加socket到epoll实例中。// 关闭socket和epoll实例。// 设置socket地址和端口。// 创建UDP socket。// 创建epoll实例。// 绑定socket。
c++ inotify+epoll实现异步文件监控
www_dong的博客
07-31 915
动态监测linux系统某一个目录下文件的变化。具体使用场景如linux下应用程序运行时产生日志文件，尤其在程序出现某种异常时，日志文件记录着错误出现的原因、时间及代码位置等信息，此时日志文件在增长，但是采用轮询的方式定时查看日志文件尤为消耗性能。基于此问题，采用**“epoll+inotify异步文件监控”**的方式可以实现日志的动态刷新。
海量接入-epoll技术详解
lipingcheng的专栏
12-22 447
Epoll详解
epoll详细工作原理.docx
04-29
epoll 工作原理详解 epoll 是一种高效的 IO 多路复用技术，可以处理数以百万计的 socket 句柄。它的高效性来自于其巧妙的设计和实现。下面我们将深入探讨 epoll 的工作原理。 epoll_create epoll_create 是建立一...
LinuxIO模式及select、poll、epoll详解
02-26
看到这篇文章说明你已经从老版本升级到Ubuntu16.04或进行了全新安装，在安装好Ubuntu16.04LTS之后建议大家先做如下15件事。无论你是刚加入Ubuntu行列的新用户，还是有经验的老用户，你都会发现一些非常有用的调整和...
完成端口epoll
01-31
网络编程，使用epoll，类似于window的完成端口，可支持多连接，多到几千个同时过来的连接，都能处理。最高效率的方式，没有之一。
linux下通过epoll机制进行串口监听并转发tcp
09-02
Linux下通过epoll机制进行串口监听，当收到数据时，通过tcp进行数据转发给服务器
epoll两种监听模式
zhanghaodx082的专栏
09-17 968
Edge Triggered 工作模式：  如果我们在第1步将RFD添加到epoll描述符的时候使用了EPOLLET标志，那么在第5步调用epoll_wait(2)之后将有可能会挂起，因为剩余的数据还存在于文件的输入缓冲区内，而且数据发出端还在等待一个针对已经发出数据的反馈信息。只有在监视的文件句柄上发生了某个事件的时候 ET 工作模式才会汇报事件。因此在第5步的时候，调用者可能会放弃等待仍在存
端口监听的原理和作用是什么
wangSeeyin的博客
04-02 4995
端口监听的原理和作用是什么？ 在Server端为何一定要对服务端口进行监听？这样做的目的和作用是什么？ 如果不进行监听会有什么影响？
epoll详解_epoll详解——从功能到内核
weixin_39681171的博客
11-29 205
首先我们了解一下什么是I/O复用。I/O就是指网络中的I/O(即输入输出)，多路是指多个TCP连接，复用是指一个或少量线程被重复使用。连起来理解就是，用少量的线程来处理网络上大量的TCP连接中的I/O。常见的I/O复用有以下三种：selectpollepoll为什么使用epoll?这个问题也可以理解为epoll相比于select和poll有什么缺点。首先我们来分析一下select。select函数...
TCP 端口监听队列原理
weixin_30270561的博客
03-04 484
近期需要实现一个TCP线程池服务，该服务需要能够在同一个端口上实现 TCP 常规服务、HTTP请求服务、SOAP WebService 服务，为了测试 ACE 的线程池启动后，如果所有线程都在忙，客户端的连接是否还能够建立，特实现了一个简单的测试程序，如下： ACE_TP_TEST#include"stdafx.h"//=====================================...
5-5 监听端口实战、epoll介绍及原理详析
昔拉的博客
03-15 425
一：监听端口 （1.1）开启监听端口 二：epoll技术简介 （2.1）epoll概述 //(1)I/O多路复用：epoll就是一种典型的I/O多路复用技术:epoll技术的最大特点是支持高并发； //传统多路复用技术select,poll，在并发量达到1000-2000，性能就会明显下降； //epoll,kquene(freebsd) //epoll，从linux内核2.6引入的，2.6之前是...
Linux端口监听机制
Michael
04-01 727
监听端口的概念涉及到网络概念与TCP状态集转化概念，可能比较复杂不便理解，可以按照下图简单进行理解？ 　　将整个服务器操作系统比喻作为一个别墅 　　服务器上的每一个网卡比作是别墅中每间房间 　　服务器网卡上配置的IP地址比喻作为房间中每个人 　　而房间里面人的耳朵就好比是监听的端口 　　当默认采用监听0.0.0.0地址时，表示房间中的每个人都竖起耳朵等待别墅外面的人呼唤 　　当别墅外面的用户向房间1的人呼喊时，房间1里面的人员会做出响应； 　　当别墅外面的用户向房间2的人呼喊时，...
众所周知的端口号是什么意思？底层原理是什么？
长风破浪会有时的博客
07-11 319
其中，0到1023之间的端口号被称为"well-known"（众所周知）端口号，用于标识一些广泛使用的服务和协议，如HTTP的端口号80、HTTPS的端口号443等。1024到49151之间的端口号是"registered"（注册）端口号，用于标识一些已经被注册的应用程序。通过端口号的分配和管理机制，不同的应用程序可以通过指定不同的端口号来提供和访问网络服务，实现了多应用程序之间的并行通信。端口号的识别：在网络通信中，数据包中的源端口号和目标端口号用于识别发送和接收的应用程序。
客户端到服务器端的通信过程及原理
时光代码
01-02 6265
学习任何东西，我们只要搞清楚其原理，就会触类旁通。现在结和我所学，我想总结一下客户端到服务器端的通信过程。只有明白了原理，我们才会明白当我们程序开发过程中错误的问题会出现在那，才会更好的解决问题。 我们首先要了解一个概念性的词汇：Socket socket的英文原义是“孔”或“插座”。作为进程通信机制，取后一种意思。通常也称作“套接字”，用于描述IP地址和端口，是一个通信链的句柄。(其
Linux epoll原理与实战：高性能服务器多路复用技术
本文将深入解析Epoll的工作原理，并通过实战例子来展示其在实际开发中的应用。 首先，理解I/O模型是关键。传统的I/O模型主要有以下几种： 1. **阻塞式I/O (Blocking I/O)**: 当应用程序尝试读取或写入数据时，如果...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值