解决在epoll中accept接收端口会漏处理的问题. 直到新的socket消息到达，epoll_wait才响应去接收socket端口数据的问题

最新推荐文章于 2024-03-12 10:50:29 发布
最新推荐文章于 2024-03-12 10:50:29 发布
阅读量2.3k 收藏
点赞数
分类专栏： 网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Season_hangzhou/article/details/42525989
版权
本文探讨了在使用epoll时遇到的accept接收端口处理遗漏问题，即在没有新socket消息到达时，epoll_wait不会响应接收端口数据。针对此问题，文章分析原因并提供了解决方案。
摘要由CSDN通过智能技术生成
在用epoll的边缘触发模式中，发现socket接收有异常，有时会出现新的socket连接到底，但是需要有新的数据到底时，epoll_wait才响应去接收数据这个问题。

原因分析：
epoll的边缘触发模式下，同一端口可读时，epoll_wait只会提示一次。在accept中，当2个端口同时到达时，只会响应一次。这时就要用 while等循环函数去接收消息和接收accept响应，一般接收消息大家都会做，接收accept响应会忘。

代码修改：

老代码：

    INT32 conn_fd = accept( listen_fd, (sockaddr *)&clientaddr, &clilen );//accept4( event_fd, (sockaddr *)&clientaddr, &clilen, SOCK_NONBLOCK )
    if( conn_fd < 0 ) {
        MS_LOGER_FATAL("%s%s%s%s", LOG_CMD_FLAG , LOG_VOD_FLAG , "accept error" , strerror( errno ));
    } else {
        MS_LOGER_DEBUG("%s%s%s%d", LOG_CMD_FLAG , LOG_VOD_FLAG , "conn fd" , conn_fd);
    }


新代码：
 

                

        

        

    

  


        

            

                    
                      最低0.47元/天 解锁文章
                        
                    
            

        

    

      

        

            

              
                
                  Season_hangzhou
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
Linux accept()/epoll_wait()惊群问题与解决方案

				
			

			

				

					黑板报
				

				

					01-18
					
					7393
					
				

			

		

		

			
				
Linux accept()/epoll_wait()惊群问题与解决方案

			
		

	



                

              
                



	

		

			

				
					
在epoll中添加一个刚创建的socket时的情况

				
			

			

				

					SlenderJ的博客
				

				

					02-08
					
					494
					
				

			

		

		

			
				
今天读代码的时候，发现一个奇怪的操作：
一个线程在调用socket()函数后，并没有执行connect或listen操作 而是直接将这个socket加入了epoll中 来监听EPOLLIN时间
而在另外一个线程中 使用epoll_wait()却直接将这个socket作为一个就绪的描述符返回了


十分好奇这个socket是触发了什么事件，于是做了一个小实验，打印出了此socket触发时的

			
		

	



                


  
              

                


	

		

			

				
					
epoll简介与示例的整理

				
			

			

				

					永远在跟随，从未去超越
				

				

					04-08
					
					1721
					
				

			

		

		

			
				
名词解释：man epoll之后，得到如下结果： NAME        epoll - I/O event notification facility SYNOPSIS        #include  DEscrīptION        epoll is a variant of poll(2) that can be used either as Edge or Level        

			
		

	





	

		

			

				
					
epoll处理高并发连接丢失连接的问题

				
			

			

				

					ljq550000的专栏
				

				

					05-30
					
					2985
					
				

			

		

		

			
				
epoll的LT和ET的区别

LT：水平触发，效率会低于ET触发，尤其在大并发，大流量的情况下。但是LT对代码编写要求比较低，不容易出现问题。LT模式服务编写上的表现是：只要有数据没有被获取，内核就不断通知你，因此不用担心事件丢失的情况。
ET：边缘触发，效率非常高，在并发，大流量的情况下，会比LT少很多epoll的系统调用，因此效率高。但是对编程要求高，需要细致的处理每个请求，否则容易发

			
		

	



		

			
		



	

		

			

				
					
epoll边沿触发漏报消息包问题

				
			

			

				

					liberalman的专栏
				

				

					08-05
					
					2681
					
				

			

		

		

			
				
开发一个即时通讯后台，底层的网络收发使用 epoll + main loop实现网络事件(conn、read、send)的异步触发读写，以达到能最大限度减少线程的IO等待，提高cup利用率的目的。实际使用中，会发现有少量并没有 因为访问后端阻塞 但是依然反馈慢到超时的情况，我们定义从客户端发消息到收到反馈，3s超时，而我们发现延迟可能好几分钟，这让我觉得肯定不是后端一些复杂逻辑导致的，逻辑层再复杂，

			
		

	





	

		

			

				
					
accept 与 epoll 惊群

				
			

			

				

					笔记
				

				

					06-17
					
					687
					
				

			

		

		

			
				
首先，我们看看维基百科对惊群的定义:简而言之，惊群现象（thundering herd）就是当多个进程和线程在同时阻塞等待同一个事件时，如果这个事件发生，会唤醒所有的进程，但最终只可能有一个进程/线程对该事件进行处理，其他进程/线程会在失败后重新休眠，这种性能浪费就是惊群。考虑如下场景：主进程创建 socket、bind、 listen 之后，fork 出多个子进程，每个子进程都开始循环处理（accept)这个 socket。每个进程都阻塞在 accpet 上，当一个新的连接到来时，所有的进程都会被唤醒，但

			
		

	





	

		

			

				
					
linux-xia-epoll-socket.rar_epoll_epoll socket_socket_windows soc

				
			

			

				

					09-22
				

			

		

		

			
				
在Linux操作系统中，`epoll`是一个用于处理大量并发I/O事件的高效机制，尤其适用于网络编程中的套接字（socket）操作。`epoll`是`poll`和`select`模型的升级版，旨在解决高并发场景下的性能瓶颈问题。在本资料包中，...

			
		

	





	

		

			

				
					
linux epoll服务器+windows 客户端 socket tcp通信的例子.zip

				
			

			

				

					01-19
				

			

		

		

			
				
 - 当使用epoll时，将socket添加到epoll实例中，设置为监听读事件，然后进入`epoll_wait()`的循环，当有新的连接请求时，调用`accept()`接受连接，再将新连接的socket加入epoll实例。  5. **Windows客户端编程**  - ...

			
		

	





	

		

			

				
					
linux 多线程或多进程 epoll处理 accept 惊群问题

				
			

			

				

					Linux高级开发的博客
				

				

					02-21
					
					3053
					
				

			

		

		

			
				
什么是惊群

简单说，惊群是因为多进程（多线程）在同时阻塞等待同一个事件的时候（休眠状态），当时间发生时，就会唤醒所有等待的（休眠的）进程（线程）。但是事件只能被一个进程或线程处理，而其他进程（线程）获取失败，只能重新进入休眠状态，这种现象和性能浪费就叫做惊群。

产生惊群的条件

多个进程或者多个线程
	同时等待处理一个事件
具体场景复现

测试环境 :

debian11
	内核5.10.0-8
	编译器 clang11
多线程和多进程在惊群问题上差不多，为了少些一点，下文中没有特殊说明，多线程 也包含

			
		

	





	

		

			

				
					
使用epoll()进行socket编程处理多客户连接的TCP服务器实例

					
最新发布

				
			

			

				

					whowin
				

				

					03-12
					
					328
					
				

			

		

		

			
				
在网络编程中，当需要使用单线程处理多客户端的连接时，常使用select()或者poll()来处理，但是当并发数量非常大时，select()和poll()的性能并不好，epoll()的性能大大好于select()和poll()，在编写大并发的服务器软件时，epoll()应该是首选的方案，本文介绍epoll()在网络编程中的使用方法，本文提供了一个具体的实例，并附有完整的源代码。

			
		

	





	

		

			

				
					
epoll读到一半又有新事件来了怎么办？

				
			

			

				

					帅东's Blog
				

				

					05-08
					
					4652
					
				

			

		

		

			
				
有哥们在腾讯面试被问到了。我也很好奇就做了下实验。有些朋友急性子想看过程只想知道结果，我就先给出结果吧。
  1.阻塞读数据（不用epoll），你说读到一半有新消息又来了怎么办？ 
  2.非阻塞读数据（不用epoll），你说读到一半有新消息又来了怎么办？ 
  3.epoll的ET模式时,如果数据只读了一半,也就是缓冲区的数据只读了一点,然后又来新事件了怎么办？
答
  1：来了就来了呗，读就是了

			
		

	





	

		

			

				
					
socket通信报文接受不完整或者接收不到的问题

					
热门推荐

				
			

			

				

					mjjyszazc的博客
				

				

					01-17
					
					1万+
					
				

			

		

		

			
				
一、问题描述：
socket通信中经常会遇到返回报文接收不全甚至完全没有接收到的问题。
二、解决方案：
发送方在报文头用固定长度的字节声明该报文正文长度，注意这里的报文正文不包括表示报文长度的字符串本身。接收方在接收报文时先按约定读取报文长度的声明，转换为数字类型，再根据该长度读取报文内容，以避免漏读的情况。
三、代码实现（Java）：
以8位长度的报文头表示报文正文长度为例，此时报文接收方的示例...

			
		

	





	

		

			

				
					
网络编程：epoll多路复用实现多客户端的监听accept和write函数的阻塞解除

				
			

			

				

					qq_42343682的博客
				

				

					03-31
					
					748
					
				

			

		

		

			
				
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(文件描述符, 事件状态， 要监听的文件描述符， 结构体)
事件状态：

			
		

	





	

		

			

				
					
linux下epoll模型并发问题

				
			

			

				

					weixin_34166847的博客
				

				

					07-17
					
					172
					
				

			

		

		

			
				
最近用c++实现了贝叶斯分类算法，做了个自动识别垃圾信息的小工具。工具中有个功能，通过绑定指定端口，和客户端通信。服务端使用的是epoll网络模型。在测试的时候发现，单用户的情况下客户端和服务器通信正常。但是在多用户并发的情况下，客户端和服务端通信不正常。此时，客户端能正常的链接，发送数据，但是一直卡在接收数据部分。如下图：出现这种问题，是因为不正确的使用了epoll中的E...

			
		

	





	

		

			

				
					
(转载)一个简短的epoll服务器示例, 监听5000个端口, 使用线程池[safedead.cublog.cn] 

				
			

			

				

					在路上……
				

				

					09-06
					
					904
					
				

			

		

		

			
				
明天调试一下，今天看到的，先放上来！作者是safedead文章地址：http://www.cublog.cn/u/17999/showart.php?id=159057运行这个程序需要预先设置栈内存和文件描述符上限, 否则运行失败ulimit -n 16384ulimit -s 4096文件名:server.c编译: gcc server.c -Wall -O2 -pthread -o serve

			
		

	





	

		

			

				
					
深入理解epoll

				
			

			

				

					EquinoxM的博客
				

				

					03-25
					
					2053
					
				

			

		

		

			
				
intmain(){
listen(lfd,...);
cfd1=accept(...);
cfd2=accept(...);
efd=epoll_create(...);
epoll_ctl(efd,EPOLL_CTL_ADD,cfd1,...);
epoll_ctl(efd,EPOLL_CTL_ADD,cfd2,...);
epoll_wait(efd,...)
}


和epoll相关的函数主要有三个：


	ep...

			
		

	





	

		

			

				
					
I/O复用三种方式的比较

				
			

			

				

					Tangbincheng的博客
				

				

					04-17
					
					953
					
				

			

		

		

			
				
       select，poll，epoll都是IO多路复用的机制。    I/O多路复用就是通过一种机制，一个进程可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。但select，poll，epoll本质上都是同步I/O，因为他们都需要在读写事件就绪后自己负责进行读写，也就是说这个读写过程是阻塞的，而异步I/O则无需自己负责进行读写，异步I/O...

			
		

	





	

		

			

				
					
分析epoll当中的边缘触发以及水平触发模式与阻塞和非阻塞模式的多种组合

				
			

			

				

					qq_38158479的博客
				

				

					08-08
					
					284
					
				

			

		

		

			
				
一：连接套接字的  “ET+阻塞模式”
（1）采用循环的方式读取数据
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <stdio.h>
#i

			
		

	





	

		

			

				
					
socket epoll 实现

				
			

			

				

					03-28
				

			

		

		

			
				
Socket epoll是Linux中的网络I/O模型之一，它是一种高效的I/O多路复用机制，能够同时监听多个文件描述符，当其中任意一个文件描述符发生事件时，就能够通知应用程序进行相应的处理。

实现epoll的基本步骤如下：

1. 创建一个epoll实例，使用epoll_create函数。

2. 向epoll实例中添加监听事件，使用epoll_ctl函数。

3. 调用epoll_wait函数等待事件的发生，如果有事件发生，则返回就绪的文件描述符列表。

4. 根据就绪的文件描述符进行相应的处理。

下面是一个简单的示例代码，实现了一个简单的TCP服务器，使用epoll监听多个连接：

#include <sys/epoll.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#define MAX_EVENTS 10
#define BUFFER_SIZE 1024

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

int main() {
    int server_fd, client_fd, epoll_fd, nfds, n, i;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_len;
    char buffer[BUFFER_SIZE];
    struct epoll_event ev, events[MAX_EVENTS];

    // 创建socket
    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd < 0) {
        perror("socket");
        exit(1);
    }

    // 设置socket为非阻塞模式
    if (setnonblocking(server_fd) < 0) {
        perror("setnonblocking");
        exit(1);
    }

    // 绑定地址和端口
    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(12345);
    if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind");
        exit(1);
    }

    // 开始监听
    if (listen(server_fd, SOMAXCONN) < 0) {
        perror("listen");
        exit(1);
    }

    // 创建epoll实例
    epoll_fd = epoll_create1(0);
    if (epoll_fd < 0) {
        perror("epoll_create1");
        exit(1);
    }

    // 添加server_fd到epoll实例中
    ev.events = EPOLLIN;
    ev.data.fd = server_fd;
    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_fd, &ev) < 0) {
        perror("epoll_ctl");
        exit(1);
    }

    while (1) {
        // 等待事件的发生
        nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
        if (nfds < 0) {
            perror("epoll_wait");
            exit(1);
        }

        // 处理就绪的文件描述符
        for (i = 0; i < nfds; i++) {
            if (events[i].data.fd == server_fd) {
                // 有新的连接请求
                client_len = sizeof(client_addr);
                client_fd = accept(server_fd, (struct sockaddr *)&client_addr, &client_len);
                if (client_fd < 0) {
                    perror("accept");
                    continue;
                }

                // 设置client_fd为非阻塞模式
                if (setnonblocking(client_fd) < 0) {
                    perror("setnonblocking");
                    exit(1);
                }

                // 添加client_fd到epoll实例中
                ev.events = EPOLLIN | EPOLLET;
                ev.data.fd = client_fd;
                if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &ev) < 0) {
                    perror("epoll_ctl");
                    exit(1);
                }
            } else {
                // 有数据可读
                memset(buffer, 0, BUFFER_SIZE);
                while ((n = read(events[i].data.fd, buffer, BUFFER_SIZE)) > 0) {
                    printf("Received %d bytes: %s\n", n, buffer);
                }
                if (n < 0 && errno != EAGAIN) {
                    perror("read");
                    exit(1);
                }

                // 关闭连接
                if (n == 0) {
                    if (epoll_ctl(epoll_fd, EPOLL_CTL_DEL, events[i].data.fd, NULL) < 0) {
                        perror("epoll_ctl");
                        exit(1);
                    }
                    close(events[i].data.fd);
                }
            }
        }
    }

    return 0;
}

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		
评论 1

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值