Linux(程序设计):52---epoll处理套接字在LT、ET不同模式下的数据

最新推荐文章于 2023-07-29 19:27:03 发布
最新推荐文章于 2023-07-29 19:27:03 发布
阅读量815 收藏 6
点赞数
分类专栏： Linux(程序设计) 文章标签： epoll同时处理LT模式、ET模式数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41453285/article/details/103141158
版权

 一、epoll的LT模式、ET模式介绍

二、编码实现

  • 下面我们通过epoll来分别实现对LT和ET不同模式下对数据是如何处理的
  • 如果我们的服务端监听套接字设置为EPOLLET模式工作，那么当服务端接收到客户端的请求(读写数据等)之后，可能会将这个就绪事件不立即进行处理，而是保留放到下一次epoll_wait进行处理。下面程序我们将服务端的监听套接字设置为EPOLLET模式的，所以当服务端接收到客户端的请求(例如：数据的接受)时，必须在本次epoll_wait返回之后进行处理，不能将本次的就绪事件放置到下一次epoll_wait去处理
  • 另外，在普通模式下工作的时候(下面的work_with_LT函数)，我们服务端接收客户端的数据可能不会一次性读取完，可能还有数据保存在缓冲区中未读取。然后在ET工作模式下下面的(work_with_ET函数)，我们接收到客户端发送过来数据的时候，由于本次事件处理完之后，下一次就不会再次触发了，所以我们使用while(1)循环读取客户端套接字的缓冲区数据，直到读取完之后才退出本次EPOLLIN事件处理
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <sys/select.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

#define BUFFSIZE 1024
#define LISTEN_NUM 10
#define MAX_EPOLLEVENT_NUM  1024

int setnonblock(int fd);
void addEpollFd(int epoll_fd,int add_fd,int enable_et);
void work_with_LT(int epoll_fd,int epoll_ret_value,int ser_fd,struct epoll_event *read_events);
void work_with_ET(int epoll_fd,int epoll_ret_value,int ser_fd,struct epoll_event *read_events);

int main(int argc,char *argv[])
{
    char *ip=argv[1];
    int port=atoi(argv[2]);

    int serverAlive;
    int serFd,epollFd;
    int epollRetValue,waitTimeValue;
    struct epoll_event readyEvent[MAX_EPOLLEVENT_NUM];
    struct sockaddr_in serAddr;

    if((serFd=socket(AF_INET,SOCK_STREAM,0))==-1){
        perror("socket");
        exit(EXIT_FAILURE);
    }

    bzero(&serAddr,sizeof(serAddr));
    serAddr.sin_family=AF_INET;
    serAddr.sin_port=htons(port);
    if(inet_pton(AF_INET,ip,&serAddr.sin_addr.s_addr)==-1){
        perror("inet_pton");
        exit(EXIT_FAILURE);
    }

    if(bind(serFd,(struct sockaddr*)&serAddr,sizeof(serAddr))==-1){
        perror("inet_pton");
        exit(EXIT_FAILURE);
    }    

    if(listen(serFd,LISTEN_NUM)==-1){
        perror("listen");
        exit(EXIT_FAILURE);
    }
    serverAlive=1;

    if((epollFd=epoll_create(5))==-1){
        perror("epoll_create");
        exit(EXIT_FAILURE);
    }

    addEpollFd(epollFd,serFd,1);
    
    while(serverAlive)
    {
        waitTimeValue=3000;
        printf("epoll_wait...\n");
        switch(epollRetValue=epoll_wait(epollFd,readyEvent,MAX_EPOLLEVENT_NUM,waitTimeValue))
        {
            case -1:
                perror("epoll_wait");
                serverAlive=0;
                break;
            case 0:
                printf("epoll_wait timeout\n");
                break;
            default:
                //work_with_ET(epollFd,epollRetValue,serFd,readyEvent);
                work_with_LT(epollFd,epollRetValue,serFd,readyEvent);
                break;
        }
    }
    
    exit(EXIT_SUCCESS);
}

int setnonblock(int fd)
{
    int oldFlags,newFlags;
    if((oldFlags=fcntl(fd,F_GETFL))==-1){
        perror("fcntl ");
        exit(EXIT_FAILURE);
    }
    newFlags = oldFlags|O_NONBLOCK;
    if(fcntl(fd,F_SETFL,newFlags)==-1){
        perror("fcntl ");
        exit(EXIT_FAILURE);
    }
    return oldFlags;
}

void addEpollFd(int epoll_fd,int add_fd,int enable_et)
{
    struct epoll_event event;
    bzero(&event,sizeof(event));
    event.events=EPOLLIN;
    event.data.fd=add_fd;

    if(enable_et){
        event.events 
|= EPOLLET;
    }
    
    if(epoll_ctl(epoll_fd,EPOLL_CTL_ADD,add_fd,&event)==-1){
        perror("epoll_ctl");
        exit(EXIT_FAILURE);
    }
    setnonblock(add_fd);
}

void work_with_LT(int epoll_fd,int epoll_ret_value,int ser_fd,struct epoll_event *read_events)
{
    int i,acceptFd,commRetValue;
    char commBuff[BUFFSIZE];
    char cliAddrBuf[24];
    char serBuff[]=
"I am server\n";
    socklen_t cliAddrLen;
    struct sockaddr_in cliAddr;
    struct epoll_event cliEvents;
    
    bzero(&cliAddr,sizeof(cliAddr));
    cliAddrLen=sizeof(cliAddr);
    
    for(i=0;i<epoll_ret_value;++i)
    {
        if((read_events[i].data.fd==ser_fd)&&(read_events[i].events&EPOLLIN)){
            if((acceptFd=accept(ser_fd,(struct sockaddr*)&cliAddr,&cliAddrLen))==-1){
                if(errno==EINTR){
                    printf("accept:catch signal...\n");
                    continue;
                }
                perror("accept");
                exit(EXIT_FAILURE);
            }else{
                if(inet_ntop(AF_INET,&cliAddr.sin_addr.s_addr,cliAddrBuf,sizeof(cliAddrBuf))==NULL){
                    printf("Get Connect: an unrecognized client address\n");
                }else{
                    printf("Get Connect: %s:%d\n",cliAddrBuf,ntohl(cliAddr.sin_port));
                }
                addEpollFd(epoll_fd,acceptFd, 0);
            }
        }
        else if(read_events[i].events&EPOLLIN){
            bzero(commBuff,sizeof(commBuff));
            switch(commRetValue=recv(read_events[i].data.fd,commBuff,sizeof(commBuff),0))
            {
            case 0:
                printf("client close\n");
                if(epoll_ctl(epoll_fd,EPOLL_CTL_DEL,read_events[i].data.fd,NULL)==-1){
                        perror("epoll_ctl");
                        exit(EXIT_FAILURE);
                }
                close(read_events[i].data.fd);
                break;
            case -1:
                perror("recv");
                close(read_events[i].data.fd);
                close(ser_fd);
                exit(EXIT_FAILURE);
            default:
                printf("Get data of client:%s\n",commBuff);
                
                if(bcmp(commBuff,"quit",4)==0){
                    if(epoll_ctl(epoll_fd,EPOLL_CTL_DEL,read_events[i].data.fd,NULL)==-1){
                        perror("epoll_ctl");
                        exit(EXIT_FAILURE);
                    }
                    close(read_events[i].data.fd);
                }
                
                cliEvents.events=EPOLLOUT;
                cliEvents.data.fd=read_events[i].data.fd;
                
                if(epoll_ctl(epoll_fd,EPOLL_CTL_MOD,read_events[i].data.fd,&cliEvents)==-1){
                    perror("epoll_ctl");
                    exit(EXIT_FAILURE);
                }
                break;
            }
        }
        else if(read_events[i].events&EPOLLOUT){
            bzero(commBuff,sizeof(commBuff));
            bcopy(serBuff,commBuff,sizeof(serBuff));
        
            switch(commRetValue=send(read_events[i].data.fd,commBuff,sizeof(commBuff),0))
            {
            case -1:
                perror("recv");
                close(read_events[i].data.fd);
                close(ser_fd);
                exit(EXIT_FAILURE);
            default:
                if(bcmp(commBuff,"quit",4)==0){
                    if(epoll_ctl(epoll_fd,EPOLL_CTL_DEL,read_events[i].data.fd,NULL)==-1){
                        perror("epoll_ctl");
                        exit(EXIT_FAILURE);
                    }
                    close(read_events[i].data.fd);
                }
                cliEvents.events=EPOLLIN;
                cliEvents.data.fd=read_events[i].data.fd;
                
                if(epoll_ctl(epoll_fd,EPOLL_CTL_MOD,read_events[i].data.fd,&cliEvents)==-1){
                    perror("epoll_ctl");
                    exit(EXIT_FAILURE);
                }
                break;
            }
        }
    }
}

void work_with_ET(int epoll_fd,int epoll_ret_value,int ser_fd,struct epoll_event *read_events)
{
    int i,acceptFd,commRetValue;
    char commBuff[BUFFSIZE];
    char cliAddrBuf[24];
    char serBuff[]=
"I am server\n";
    socklen_t cliAddrLen;
    struct sockaddr_in cliAddr;
    struct epoll_event cliEvents;
    
    bzero(&cliAddr,sizeof(cliAddr));
    cliAddrLen=sizeof(cliAddr);
    
    for(i=0;i<epoll_ret_value;++i)
    {
        if((read_events[i].data.fd==ser_fd)&&(read_events[i].events&EPOLLIN)){
            if((acceptFd=accept(ser_fd,(struct sockaddr*)&cliAddr,&cliAddrLen))==-1){
                if(errno==EINTR){
                    printf("accept:catch signal...\n");
                    continue;
                }
                perror("accept");
                exit(EXIT_FAILURE);
            }else{
                if(inet_ntop(AF_INET,&cliAddr.sin_addr.s_addr,cliAddrBuf,sizeof(cliAddrBuf))==NULL){
                    printf("Get Connect: an unrecognized client address\n");
                }else{
                    printf("Get Connect: %s:%d\n",cliAddrBuf,ntohl(cliAddr.sin_port));
                }
                addEpollFd(epoll_fd,acceptFd, 0);
            }
        }
        else if(read_events[i].events&EPOLLIN){
            while(1)
            {
                bzero(commBuff,sizeof(commBuff));
                commRetValue=recv(read_events[i].data.fd,commBuff,sizeof(commBuff),0);
                if(commRetValue==0){
                    printf("client close\n");
                    if(epoll_ctl(epoll_fd,EPOLL_CTL_DEL,read_events[i].data.fd,NULL)==-1){
                        perror("epoll_ctl");
                        exit(EXIT_FAILURE);
                    }
                    close(read_events[i].data.fd);
                    break;
                }
                else if(commRetValue==-1){
                    if((errno==EAGAIN)||(errno==EWOULDBLOCK)){
                        printf("End of reading...\n");
                        cliEvents.events=EPOLLOUT;
                        cliEvents.data.fd=read_events[i].data.fd;  
                        if(epoll_ctl(epoll_fd,EPOLL_CTL_MOD,read_events[i].data.fd,&cliEvents)==-1){
                            perror("epoll_ctl");
                            exit(EXIT_FAILURE);
                        }
                        break;
                    }
                    perror("recv");
                    close(read_events[i].data.fd);
                    close(ser_fd);
                    exit(EXIT_FAILURE);
                }
                else{
                    printf("Get data of client:%s\n",commBuff);
                
                    if(bcmp(commBuff,"quit",4)==0){
                        if(epoll_ctl(epoll_fd,EPOLL_CTL_DEL,read_events[i].data.fd,NULL)==-1){
                            perror("epoll_ctl");
                            exit(EXIT_FAILURE);
                        }
                        close(read_events[i].data.fd);
                    }
                }
            }
        }
        else if(read_events[i].events&EPOLLOUT){
            bzero(commBuff,sizeof(commBuff));
            bcopy(serBuff,commBuff,sizeof(serBuff));
        
            switch(commRetValue=send(read_events[i].data.fd,commBuff,sizeof(commBuff),0))
            {
            case -1:
                perror("recv");
                close(read_events[i].data.fd);
                close(ser_fd);
                exit(EXIT_FAILURE);
            default:
                if(bcmp(commBuff,"quit",4)==0){
                    if(epoll_ctl(epoll_fd,EPOLL_CTL_DEL,read_events[i].data.fd,NULL)==-1){
                        perror("epoll_ctl");
                        exit(EXIT_FAILURE);
                    }
                    close(read_events[i].data.fd);
                }
                cliEvents.events=EPOLLIN;
                cliEvents.data.fd=read_events[i].data.fd;
                
                if(epoll_ctl(epoll_fd,EPOLL_CTL_MOD,read_events[i].data.fd,&cliEvents)==-1){
                    perror("epoll_ctl");
                    exit(EXIT_FAILURE);
                }
                break;
            }
        }
    }
}

先整体介绍程序

  • ①老规矩，先创建一个服务端套接字，然后绑定、监听等

  • ②我们创建一个epoll的句柄，然后将我们的服务端监听socket添加进epoll事件表，服务端监听socket为EPOLLIN与EPOLLET模式（设置为EPOLLET之后，我们的监听套接字在接收到服务端的请求(比如数据的发送，连接)，那么服务端必须在一次epoll_wait返回中处理完这些请求，不能暂时不处理，留到下一次epoll_wait来处理）

  • addEpollFd函数使我们自己创建的函数，参数1位epoll的句柄，参数2位要添加进epoll事件表的套接字，参数3为添加的套接字是否设置为EPOLLET类型（ET）

  • 另外，我们需要将套接字都设置为非阻塞的。所以我们也自定义了一个将套接字设置为非阻塞的setnonblock函数，该函数返回套接字之前的套接字标志

  • ③之后，使用主线程中的大while循环，持续进行epoll_wait，等待epoll事件池中有哪些事件已经准备好开始操作了，如果epoll_wait返回正确就调用我们自定义的“work_with_ET”或“work_with_LT”函数，来实现在不同的模式下epoll是如何工作的

work_with_LT函数（epoll的LT处理模式）

  • 这个模式是epoll的默认工作方式，下面我们来详细介绍这个工作方式如何与客户进行交互。此函数的参数分别为：epoll的句柄，epoll_wait的成功返回值，服务端的socket，以及epoll_wait成功返回之后存放着就绪事件的struct epoll_event结构体
  • ①首先定义一些变量在下面使用(就不详细介绍了，用的时介绍)，然后通过主for循环来判断epoll_wait返回的这些就绪事件当中分别是哪些事件

  • ②首先判断就绪事件的fd是否为我们服务端的socket，由于服务端的监听套接字是非阻塞的，并且工作模式为EPOLLIN，那么当有客户端连接时才会EPOLLIN模式才会触发，此时服务端才会开始监听，所以这个if能够准确判断是否为我们服务端的socket就绪。如果是我们服务端的socket就绪，那么：
    • 使用accept来接受客户端的请求（如果accept出错返回，但errno为EINTR，说明accept是被信号中断的，所以程序不退出，继续执行）
    • accept执行成功，打印客户端地址，并且将我们的客户端socket加入到我们的epoll事件表中，并且不设置为EPOLLET模式

  • ③然后再次判断就绪的套接字是否为可读状态（EPOLLIN），也就是客户端的socket给服务端发送数据之后，EPOLLIN状态就被激活了，此时使用recv来读取缓冲区中的数据，接收数据的返回值有如下3种情况，我们使用switch来判断：
    • 如果返回0：那么客户端关闭连接，我们将客户端套接字移除epoll事件表，然后关闭客户端套接字，之后退出此次switch，继续执行for循环
    • 如果返回-1：那么就是recv出错了，我们直接关闭服务端套接字与客户端套接字退出程序
    • 如果recv成功返回：那么打印接收到打印的数据，如果服务端输入的是“quit”，那么代表客户端要终止会话，那么就将客户端套接字移出epoll事件表，然后关闭客户端套接字。如果客户端输入的不是“quit”，那么就将客户端的套接字事件类型设置为EPOLLOUT，那么代表客户端的套接字可以进行数据输出，此时我们的服务端可以向客户端发送数据了（具体在下面一个else if中判断）

  • ④同理，这个else if判断这个套接字是否为可以进行写，也就是是否可以向客户端写入数据，一开始我们的客户端被设置为EPOLLIN类型，但是当我们的客户端发送数据到服务端之后，服务端接收到数据之后将其套接字事件类型设置为EPOLLOUT了（这个是我们程序自己设计的地方）。之后我们调用send向客户端发送一些数据(commBuff)，send返回值有以下两种
    • 如果出错返回-1，出错之后关闭服务端与客户端，然后退出应用程序
    • 如果没有出错，判断一下服务端发送的内容是否为“quit”，如果为quit那么就代表服务端想与客户端会话断开，那么就用epoll_ctl将客户端的套接字移出epoll的事件表。如果不是“quit”，那么就将客户端的套接字再次设置为EPOLLIN，那么客户端就又可以向服务端发送数据了（这样就与上面那么else if形成了一个客户端与服务端可以进行数据读写交互的模式）

  • 到此，work_with_LT函数介绍完毕

work_with_ET函数（epoll的ET处理模式）

  • ET模式不是我们epoll的默认工作方式，但是我们一开始我们将服务端的套接字设置为ET模式，那么我们可以使用这个函数来测试一下epoll的ET工作模式是什么样子的
  • 这个函数与work_with_LT函数之后判断数据接收方面不一样，其他方面都是一样的
  • ①首先，与work_with_LT一样，定义一些变量在下面使用，然后通过主for循环来判断epoll_wait返回的这些就绪事件当中分别是哪些事件

  • ②判断是否为服务端的监听套接字就绪了，与work_with_LT是一模一样的

  • ③接着，判断是否为有数据可接收的套接字就绪，那么服务端就来读取这些数据，读取数据与普通的LT模式有不一样的地方，因为ET模式必须在一次处理完，并且再下次进行epoll_wait的时候讲不再相应这个事件，所以下面我们使用while循环来一次性读取完socket缓冲区中的所有数据。while的循环过程如下：
    • 如果读取的返回值为0，说明客户端关闭了套接字，那么我们就将客户端的套接字移出epoll的事件表，然后关闭客户端的套接字，之后break退出while，进行下一次的for大循环检测下一个就绪事件
    • 如果recv返回-1，那么又分为两种情况
      • 如果错误码为EAGAIN或者EWOULDBLOCK，那么就说明此次读取操作数据已经全部读取完毕，下次epoll_wai将不再响应这个EPOLLIN事件，我们就服务端的套接字设置为EPOLLOUT模式，以便下次让服务端向客户端的套接字中写入数据
      • 如果错误码不是上面的值，说明我们的recv函数出错了，那么就关闭服务端与客户端的套接字，然后终止程序
    • 如果recv返回值是正值，说明读取到数据了，那么就打印数据的信息，如果服务端发送的内容是否为“quit”，如果为quit那么就代表服务端想与客户端会话断开，那么就用epoll_ctl将客户端的套接字移出epoll的事件表（备注：因为是循环读取数据，所以不能再每读一次数据就讲客户端的套接字设置为EPOLLOUT模式，我们在第一个if中对客户端的数据读取完毕之后再将客户端的套接字设置为EPOLLOUT模式然后break掉）

  • ④与work_with_LT函数的意义一样，都是向客户端回送消息

程序演示效果（演示LT模式的）：

演示效果（演示ET模式的）：

董哥的黑板报
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
epoll中监听套接字的触发模式
萧十一的技术小站
05-21 1967
我们知道epoll有两种触发模式：水平触发(LT)和边缘触发(ET) LT模式 若数据可读，epoll返回可读事件 若开发者没有把数据完全读完，epoll会不断通知数据可读，直到数据全部被读取。 若socket可写，epoll返回可写事件，而且是只要socket发送缓冲区未满，就一直通知可写事件。 优点是对于read操作比较简单，只要有read事件就读，读多读少都可以。 E...
Epoll常见面试问题，LT和ET区别？将socket设为非阻塞？正确的读写方式？关于epoll的数据结构？epoll与select、poll的对比？
JMW1407的博客
08-13 2333
epoll——常见面试问题epoll——常见面试问题常问面试问题 epoll——常见面试问题 常问面试问题 1、Linux epoll ET模式下 EPOLLOUT和EPOLLIN触发场景？ 1、EPOLLOUT事件： EPOLLOUT事件只有在连接时触发一次，表示可写，其他时候想要触发，那你要先准备好下面条件： 1.某次write，写满了发送缓冲区，返回错误码为EAGAIN。 2.对端读取了一些数据，又重新可写了，此时会触发EPOLLOUT。 简单地说：EPOLLOUT事件只有在不可写到可写
epoll中的ET模式将套接字设置为非阻塞
weixin_38427766的博客
03-11 774
 epoll中的ET模式即边沿触发方式，在只有缓冲区从不可读到可读，从不可写到可写的转变下才会触发。 假想几种解决方式（均为ET模式下，触发EPOLLIN事件）  1.套接字描述符设置为阻塞 (1)从缓冲区读一次：此种情况下，如果一次没有从缓冲区中把数据读完，则再也不会触发EPOLLIN事件 (2)从缓冲区中一直读数据，直到没有数据可读为止，那么此时会陷入读数据阻塞状态  2.套接字描述符设置为非...
转发：epoll的边沿触发模式(ET)真的比水平触发模式(LT)快吗？(当然LT模式也使用非阻塞IO，重点是要求ET模式下的代码不能造成饥饿)
ChengChengCheng的博客
12-10 248
https://www.zhihu.com/question/20502870
epoll实现
a857351839的博客
07-31 79
在linux 没有实现epoll事件驱动机制之前，我们一般选择用select或者poll等IO多路复用的方法来实现并发服务程序。在大数据、高并发、集群等一些名词唱得火热之年代，select和poll的用武之地越来越有限，风头已经被epoll占尽。 epoll通过在Linux内核中申请一个简易的文件系统(文件系统一般用什么数据结构实现？B+树)。把原先的select/poll调用分...
linux-xia-epoll-socket.rar_epoll_epoll socket_socket_windows soc
09-22
在Linux操作系统中，`epoll`是一个用于处理大量并发I/O事件的高效机制，尤其适用于网络编程中的套接字（socket）操作。`epoll`是`poll`和`select`模型的升级版，旨在解决高并发场景下的性能瓶颈问题。在本资料包中，...
linux下使用epoll基于socket套接字的通信库。.zip
最新发布
04-29
本教程将深入探讨如何在Linux环境下使用`epoll`与`socket`套接字进行通信库的开发。 1. **I/O多路复用概念** I/O多路复用允许单个进程同时监视多个文件描述符（如套接字），等待数据到达时进行相应的处理。这种...
举源码实例来说明epoll之LT和ET模式的区别
01-01
例如，如果一个套接字上有数据待读，那么每次`epoll_wait`都会返回这个事件，直到读取完所有数据或者关闭了这个连接。下面是一个简单的LT模式源码示例： ```c int epoll_fd = epoll_create(1); struct epoll_...
pi-pi-net 是一个在linux环境下封装epoll的网络库.zip
04-29
开发过程中，开发者可以通过 `pi-pi-net` 创建监听套接字，注册事件回调，然后进入事件循环，等待并处理 `epoll` 返回的事件。对于新的连接，可以使用库提供的工具进行管理和通信。例如，你可以创建一个 Reactor ...
tinyhttpd-epoll:Tinyhttpd的epoll端口
07-06
epoll是Linux系统提供的I/O多路复用技术，它在处理大量并发连接时表现优秀，是现代高性能网络服务的基础。 epoll是边缘触发（ET）和水平触发（LT）模式的混合，相比传统的select和poll，epoll有以下优势： 1. **...
epoll实现TCP服务器和客户端收发数据
qq_45418048的博客
07-29 268
【代码】epoll实现TCP服务器和客户端收发数据。
彻底学会使用epoll(五)—— ET模式下的注意事项
weixin_39094034的博客
12-02 645
5.1ET模式下的读写 经过前面几节分析，我们可以知道，当epoll工作在ET模式下时，对于读操作，如果read一次没有读尽buffer中的数据，那么下次将得不到读就绪的通知，造成buffer中已有的数据无机会读出，除非有新的数据再次到达。对于写操作，主要是因为ET模式下fd通常为非阻塞造成的一个问题——如何保证将用户要求写的数据写完。 要解决上述两个ET模式下的读写问题，我们必须实现： a.对于读，只要buffer中还有数据就一直读； b.对于写，只要buffer还有空间且用户请求写...
EPOLL服务器ET模式下接收大数据时需要保存数据接收中间状态
Dalek的专栏
02-20 1439
EPOLL ET模式下接收大数据的问题，EPOLL MAN手册的说明只有一句话，如下 An event driven state machine application should, after having received EAGAIN, record its current state so that at the next call to do_use_fd() it will con
socket编程 -- epoll模型服务端/客户端通信的实现
wangbaba_1的博客
10-30 567
多路I/O复用之epoll 1、epoll简介      epoll是在2.6内核中提出的，是之前的select和poll的增强版本。相对于select和poll来说，epoll更加灵活，没有描述符限制。epoll使用一个文件描述符管理多个描述符，将用户关系的文件描述符的事件存放到内核的一个事件表中，这样在用户空间和内核空间的copy只需一次。 2、epoll 常用函数    epoll使用过程中，经常使用以下3个函数： in.
【网络编程】 关于epoll中的LT、ET模式和阻塞、非阻塞情况说明
Blacktone的博客
03-13 2708
关于epoll中的LT、ET模式和阻塞、非阻塞情况说明 共含有8种组合，组合元素如下 LT触发和ET触发 阻塞和非阻塞 监听套接字Lfd和读写套接字Cfd 下述情况的代码中没有循环   阻塞的Lfd epoll_wait()函数返回的是已就绪的连接，无论是否阻塞accept()函数，都会立即返回； 设置阻塞的Lfd，当客户端发起连接请求时，由于服务器繁忙未及时accept()，此时客户端自行断开，若刚好服务器空闲到达accept()，就会出现阻塞；   LT触发的Lfd非阻塞模式 正常访问，
【服务器编程】EPOLL的LT和ET模式的区别和理解
热门推荐
依然那霖哥
07-07 2万+
【前言】 epoll模型是服务器编程的高性能框架，比select 和 poll模型高效很多，当然还有其它的模型，如kqueue等，具体linux发行版提供不同的模型，一般都支持epoll吧。 【理解】 epoll提供两种工作模式：LT 和 ET。 LT模式是epoll默认的工作方式，相当于一个效率很高的poll模型；而ET是高效的工作方式。 LT 和 ET本质的区别是：
nginx如何统一处理监听套接字
阳光梦的专栏
11-25 1554
ngx_event_process_init 让所有监听套接字cycle->listening的rev->handler = ngx_event_accept，并加入epoll; ngx_event_accept函数中accept得到一个客户端socket后，进行初始化工作 c = ngx_get_connection(s, ev->log); c->pool = ngx_crea
【epoll】epoll使用详解（精髓）--研读和修正
bandaoyu的note
04-26 1万+
目录 目录 epoll - I/O epoll的接口 关于ET、LT两种工作模式 epoll程序框架 实例源码 编译命令 命令行简单测试 相关知识 Socket的阻塞模式和非阻塞模式 如何动态的改变listen监听的个数呢？ 队列已满的情况，如何处理？ SYN泛滥攻击 参考 代码二，多进程Epoll： 建立2000+个链接的测试代码 epoll - I/O ...
Linux epoll技术详解：Edge Triggered与Level Triggered模式
- 服务器创建了一个epoll专用的文件描述符`epfd`，用于管理所有的监听和已连接的套接字。 - 使用`fcntl`函数将socket设置为非阻塞模式，这样可以避免在处理连接或接收数据时阻塞主线程。 - `epoll_create`函数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

董哥的黑板报

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

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

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

打赏作者

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

抵扣说明：

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

余额充值