图文并茂讲解epoll原理，彻底弄懂epoll机制

最新推荐文章于 2024-05-13 20:03:46 发布
最新推荐文章于 2024-05-13 20:03:46 发布
阅读量1.3k 收藏 13
点赞数 2
文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60259116/article/details/134332371
版权

目录

  • 1.epoll基础简介
  • 2.epoll软件架构
  • 3.LT模式和ET模式
  • 4.阻塞和非阻塞
  • 5.epoll为什么高效？
  • 6.epoll示例程序

本文福利， 免费领取C++学习资料包、技术视频/代码，1000道大厂面试题，内容包括（C++基础，网络编程，数据库，中间件，后端开发/音视频开发/Qt开发/游戏开发等进阶学习路线图）↓↓↓↓↓↓见下面↓↓文章底部点击免费领取↓↓

1.epoll基础简介

1.1 相关函数介绍

  • epoll_create函数

epoll_create函数用于创建epoll文件描述符，该文件描述符用于后续的epoll操作，参数size目前还没有实际用处，我们只要填一个大于0的数就行。

#include <sys/epoll.h>
 
int epoll_create(int size);
 
参数：
size:目前内核还没有实际使用，只要大于0就行
 
返回值：
返回epoll文件描述符

  • epoll_ctl函数

epoll_ctl函数用于增加，删除，修改epoll事件，epoll事件会存储于内核epoll结构体红黑树中。

#include <sys/epoll.h>
 
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
 
参数：
epfd：epoll文件描述符
op：操作码
EPOLL_CTL_ADD:插入事件
EPOLL_CTL_DEL:删除事件
EPOLL_CTL_MOD:修改事件
fd：事件绑定的套接字文件描述符
events：事件结构体
 
返回值：
成功：返回0
失败：返回-1

struct epoll_event结构体

epoll_event事件结构体

#include <sys/epoll.h>
 
struct epoll_event{
  uint32_t events; //epoll事件，参考事件列表 
  epoll_data_t data;
} ;
typedef union epoll_data {  
    void *ptr;  
    int fd;  //套接字文件描述符
    uint32_t u32;  
    uint64_t u64;
} epoll_data_t;

epoll事件列表：

头文件：<sys/epoll.h>
 
enum EPOLL_EVENTS
{
    EPOLLIN = 0x001, //读事件
    EPOLLPRI = 0x002,
    EPOLLOUT = 0x004, //写事件
    EPOLLRDNORM = 0x040,
    EPOLLRDBAND = 0x080,
    EPOLLWRNORM = 0x100,
    EPOLLWRBAND = 0x200,
    EPOLLMSG = 0x400,
    EPOLLERR = 0x008, //出错事件
    EPOLLHUP = 0x010, //出错事件
    EPOLLRDHUP = 0x2000,
    EPOLLEXCLUSIVE = 1u << 28,
    EPOLLWAKEUP = 1u << 29,
    EPOLLONESHOT = 1u << 30,
    EPOLLET = 1u << 31 //边缘触发
  };
  • epoll_wait函数

epoll_wait用于监听套接字事件，可以通过设置超时时间timeout来控制监听的行为为阻塞模式还是超时模式。

#include <sys/epoll.h>
 
int epoll_wait(int epfd, struct epoll_event *events,              
int maxevents, int timeout);
 
参数：
epfd：epoll文件描述符
events：epoll事件数组
maxevents：epoll事件数组长度
timeout：超时时间
小于0：一直等待
等于0：立即返回
大于0：等待超时时间返回，单位毫秒
 
返回值：
小于0：出错
等于0：超时
大于0：返回就绪事件个数

2.epoll软件架构

3.LT模式和ET模式

3.1 LT模式：水平触发

socket读触发：socket接收缓冲区有数据，会一直触发epoll_wait EPOLLIN事件，直到数据被用户读取完。

socket写触发：socket可写，会一直触发epoll_wait EPOLLOUT事件。

3.2 ET模式：边缘触发

socket读触发：socket数据从无到有，会触发epoll_wait EPOLLIN事件，只会触发一次EPOLLIN事件，用户检测到事件后，需一次性把socket接收缓冲区数据全部读取完，读取完的标志为recv返回-1，errno为EAGAIN。

socket写触发：socket可写，会触发一次epoll_wait EPOLLOUT事件。

边缘触发读取数据示例代码：

memset(recv_buf, 0, BUF_SIZE);
unsigned int len = 0;
while(1) {
    ret = recv(fd, recv_buf + len, BUF_SIZE, 0);
    if (ret ==  0) {
        printf("remove fd:%d\n", fd);
        epoll_ctl(efd, EPOLL_CTL_DEL, fd, NULL);
        close(fd);
        break;
    } else if ((ret == -1) && ((errno == EINT macro EINTR     AGAIN) || (errno == EWOULDBLOCK))) {
        printf("fd:%d recv errno:%d done\n",
        break;                                #define EINTR 4
    } else if ((ret == -1) && !((errno == EINTR) || (errno == EAGAIN) || (errno == EWOULDBLOCK))) {
        printf("remove fd:%d errno:%d\n", fd, errno);
        epoll_ctl(efd, EPOLL_CTL_DEL, fd, NULL);
        close(fd);
        break;
    }else {
        len += ret;
    }
    printf("recv fd:%d, len:%d, %s\n", fd, ret, recv_buf);
}

4.阻塞和非阻塞

讨论epoll阻塞和非阻塞得从两方面讨论：epoll阻塞和epoll监听套接字阻塞。

epoll阻塞：epoll自身是阻塞的，我们可以通过epoll_wait超时参数设置epoll阻塞行为。

epoll监听套接字阻塞：epoll监听套接字阻塞是指插入epoll监听事件的套接字设置为阻塞模式。

epoll监听套接字设置成阻塞还是非阻塞？

这个问题可以肯定的回答是非阻塞，因为epoll是为高并发设计的，任何的其他阻塞行为，都会影响epoll高效运行。

5.epoll为什么高效？

红黑树红黑树提高epoll事件增删查改效率。

回调通知机制

当epoll监听套接字有数据读或者写时，会通过注册到socket的回调函数通知epoll，epoll检测到事件后，将事件存储在就绪队列（rdllist）。

就绪队列

epoll_wait返回成功后，会将所有就绪事件存储在事件数组，用户不需要进行无效的轮询，从而提高了效率。

6.epoll示例程序

6.1 服务端程序

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <stdbool.h>
#include <sys/epoll.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
 
#define LISTEN_BACKLOG (5)
#define BUF_SIZE (2048)
#define ONCE_READ_SIZE (1500)
 
#define EPOLL_SIZE (100);
#define MAX_EVENTS (10)
 
void usage(void) {
    printf("*********************************\n");
    printf("./server 本端ip 本端端口\n");
    printf("*********************************\n");
}
 
void setnonblocking(int fd) {
    int flag = fcntl(fd, F_GETFL, 0);
    fcntl(fd, F_SETFL, flag | O_NONBLOCK);
}
 
int main(int argc, char *argv[])
{
    struct sockaddr_in local;
    struct sockaddr_in peer;
    socklen_t addrlen = sizeof(peer);
    int sock_fd = 0, new_fd = 0;
    int ret = 0;
    char send_buf[BUF_SIZE] = {0};
    char recv_buf[BUF_SIZE] = {0};
 
    if (argc != 3) {
        usage();
        return -1;
    }
 
    char *ip = argv[1];
    unsigned short port = atoi(argv[2]);
    printf("ip:port->%s:%u\n", argv[1], port);
 
    sock_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (sock_fd == -1) {
        perror("socket error");
        return -1;
    }
 
    memset(&local, 0, sizeof(struct sockaddr_in));
    local.sin_family = AF_INET;
    local.sin_addr.s_addr = inet_addr(ip);
    local.sin_port = htons(port);
 
    ret = bind(sock_fd, (struct sockaddr *)&local, sizeof(struct sockaddr));
    if (ret == -1) {
        close(sock_fd);
        perror("bind error");
        return -1;
    }
 
    ret = listen(sock_fd, LISTEN_BACKLOG);
    if (ret == -1) {
        close(sock_fd);
        perror("listen error");
        return -1;
    }
 
    int epoll_size = EPOLL_SIZE;
    int efd = epoll_create(epoll_size);
    if (efd == -1) {
        perror("epoll create error");
        return -1;
    }
 
    struct epoll_event ev, events[MAX_EVENTS];
    ev.data.fd = sock_fd;
    ev.events = EPOLLIN;
    if (epoll_ctl(efd, EPOLL_CTL_ADD, sock_fd, &ev) == -1) {
        perror("epoll ctl ADD error");
        return -1;
    }
 
    int timeout = 1000;
    while (1) {
        int nfds = epoll_wait(efd, events, MAX_EVENTS, timeout);
        if (nfds == -1) {
            perror("epoll wait error");
            return -1;
        } else if (nfds == 0) {
            printf("epoll wait timeout\n");
            continue;
        } else {
 
        }
 
        for (int i = 0; i < nfds; i++) {
            int fd = events[i].data.fd;
            printf("events[%d] events:%08x\n", i, events[i].events);
            if (fd == sock_fd) {
                new_fd = accept(sock_fd, (struct sockaddr *)&peer, &addrlen);
                if (new_fd == -1) {
                    perror("accept error");
                    continue;
                }
                setnonblocking(new_fd);
                ev.data.fd = new_fd;
                ev.events = EPOLLIN|EPOLLET;
                if (epoll_ctl(efd, EPOLL_CTL_ADD, new_fd, &ev) == -1) {
                    perror("epoll ctl ADD new fd error");
                    close(new_fd);
                    continue;
                }
            } else {
                if (events[i].events & EPOLLIN) {
                    printf("fd:%d is readable\n", fd);
                    memset(recv_buf, 0, BUF_SIZE);
                    unsigned int len = 0;
                    while(1) {
                        ret = recv(fd, recv_buf + len, ONCE_READ_SIZE, 0);
                        if (ret ==  0) {
                            printf("remove fd:%d\n", fd);
                            epoll_ctl(efd, EPOLL_CTL_DEL, fd, NULL);
                            close(fd);
                            break;
                        } else if ((ret == -1) && ((errno == EINTR) || (errno == EAGAIN) || (errno == EWOULDBLOCK))) {
                            printf("fd:%d recv errno:%d done\n", fd, errno);
                            break;
                        } else if ((ret == -1) && !((errno == EINTR) || (errno == EAGAIN) || (errno == EWOULDBLOCK))) {
                            printf("remove fd:%d errno:%d\n", fd, errno);
                            epoll_ctl(efd, EPOLL_CTL_DEL, fd, NULL);
                            close(fd);
                            break;
                        }else {
                            printf("once read ret:%d\n", ret);
                            len += ret;
                        }
                    }
                    printf("recv fd:%d, len:%d, %s\n", fd, len, recv_buf);
                } if (events[i].events & EPOLLOUT) {
                    printf("fd:%d is sendable\n", fd);
                } else if ((events[i].events & EPOLLERR) ||
                        ((events[i].events & EPOLLHUP))) {
                    printf("fd:%d error\n", fd);
                }
            }
        }
    }
 
    return 0;
}

6.2 客户端程序

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
 
#define LISTEN_BACKLOG (5)
#define BUF_SIZE (1500)
 
#define REQUEST_STR "tcp pack"
 
void usage(void) {
    printf("*********************************\n");
    printf("./client 对端ip 对端端口\n");
    printf("*********************************\n");
}
 
int main(int argc, char *argv[])
{
    struct sockaddr_in client;
    struct sockaddr_in server;
    int sock_fd = 0;
    int ret = 0;
    socklen_t addrlen = 0;
    char send_buf[BUF_SIZE] = {0};
    char recv_buf[BUF_SIZE] = {0};
 
    if (argc != 3) {
        usage();
        return -1;
    }
 
    char *ip = argv[1];
    unsigned short port = atoi(argv[2]);
    printf("ip:port->%s:%u\n", argv[1], port);
 
    sock_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (sock_fd == -1) {
        perror("socket error");
        return -1;
    }
 
    memset(&server, 0, sizeof(struct sockaddr_in));
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = inet_addr(ip);
    server.sin_port = htons(port);
 
    ret = connect(sock_fd, (struct sockaddr *)&server, sizeof(struct sockaddr));
    if (ret == -1) {
        close(sock_fd);
        perror("connect error");
        return -1;
    }
 
    char seq = 0x31;
    while(1) {
        memset(send_buf, seq, BUF_SIZE);
        send(sock_fd, send_buf, BUF_SIZE, 0);
        printf("send %s\n", send_buf);
        sleep(2);
        seq++;
    }
    
    close(sock_fd);
 
    return 0;
}

程序员老舅
关注
  • 2
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
I/O多路复用之epoll
高性能架构探索
03-25 1917
epoll是一种事件轮询，是Linux特有的。它允许一个进程监视多个文件描述符，并在对它们进行I/O操作时获取通知。它允许边缘触发和级别触发通知。在我们研究epoll的内部之前，首先让我们研究一下语法。 语义 与poll不同，epoll本身不是系统调用。它是一种内核数据结构，允许进程在多个文件描述符上复用I/O。 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1eqsFTzC-1616657187134)(http://www.studyinfo.top/usr/upload
epoll原理详解及epoll反应堆模型
ZERO
12-10 474
转载自：https://www.toutiao.com/a6830745412157047300/?log_from=9d58e289027c2_1639110907064 设想一个场景：有100万用户同时与一个进程保持着TCP连接，而每一时刻只有几十个或几百个TCP连接是活跃的(接收TCP包)，也就是说在每一时刻进程只需要处理这100万连接中的一小部分连接。那么，如何才能高效的处理这种场景呢？进程是否在每次询问操作系统收集有事件发生的TCP连接时，把这100万个连接告诉操作系统，然后由操作系统找出其中有事
epoll_wait() 函数
最新发布
fucheng的博客
05-13 520
epoll_wait() 函数
一篇文章让你真正搞懂epoll机制
qq_40989769的博客
03-19 946
epoll机制本身也是阻塞的，当epoll_wait未检测到epoll事件时，会出让CPU，阻塞进程，这种阻塞是非常有必要的，如果不及时出让CPU会浪费CPU资源，导致其他任务无法抢占CPU，只要epoll机制能够在检测到epoll事件后，及时唤醒进程处理，并不会影响epoll性能。epoll的实现机制是通过内核与用户空间共享一个事件表，这个事件表中存放着所有需要监控的文件描述符以及它们的状态，当文件描述符的状态发生变化时，内核会将这个事件通知给用户空间，用户空间再根据事件类型进行相应的处理。
Redis IO多路复用技术以及epoll实现原理
wo4641771的博客
06-12 6966
redis 是一个单线程却性能非常好的内存数据库， 主要用来作为缓存系统。 redis 采用网络IO多路复用技术来保证在多连接的时候， 系统的高吞吐量。 为什么 Redis 中要使用 I/O 多路复用这种技术呢？ 首先，Redis 是跑在单线程中的，所有的操作都是按照顺序线性执行的，但是由于读写操作等待用户输入或输出都是阻塞的，所以 I/O 操作在一般情况下往往不能直接返回，这会导致某一文件的 I/O 阻塞导致整个进程无法对其它客户提供服务，而 I/O 多路复用就是为了解决这个问题而出现的。 redis的i
IO多路复用之epoll实例
04-23
本示例演示了使用epoll函数处理多路IO复用。本示例在ubuntu + Qt下编译通过的，仅提供学习使用。
epoll用到的epoll_create，epoll_ctl， epoll_wait三个函数，以及epoll的工作模式
qq_23114283的博客
03-24 3170
1、epoll_create函数 函数声明：int epoll_create(int size) 该 函数生成一个epoll专用的文件描述符。它其实是在内核申请一空间，用来存放你想关注的socket fd上是否发生以及发生了什么事件。size就是你在这个epoll fd上能关注的最大socket fd数。 2、epoll_ctl函数 函数声明：int epoll_ctl(in...
高并发高吞吐IO秘密武器——epoll池化技术
qq_40989769的博客
04-22 1402
epoll是Linux特有的IO复用函数，使用一组函数来完成任务，而不是单个函数。epoll把用户关心的文件描述符上的事件放在内核的一个事件表中，不需要像select、poll那样每次调用都要重复传入文件描述符集或事件集。epoll需要使用一个额外的文件描述符，来唯一标识内核中的时间表，由epoll_create创建。函数原型特别注意epoll_wait函数成功时返回就绪的文件描述符总数。select和poll返回文件描述符总数。
Epoll原理解析
weixin_42282999的博客
06-23 187
1、网络编程 //创建socket int s = socket(AF_INET, SOCK_STREAM, 0); //绑定 bind(s, ...) //监听 listen(s, ...) //接受客户端连接 int c = accept(s, ...) //接收客户端数据 recv(c, ...); //将数据打印出来 printf(...) Recv 是个阻塞方法，当程序运行到 Recv 时，它会一直等待，直到接收到数据才往下执行。那么阻塞的原理是什么? （1）工作队
linux epoll机制详解
09-15
主要介绍了linux epoll机制详解，介绍了select()和poll() IO多路复用模型，epoll IO多路复用模型实现机制，epoll的接口和工作模式等相关内容，小编觉得还是挺不错的，这里分享给大家，需要的朋友可以参考下
Epoll 原理
05-09
Epoll 原理， 可以拿来看 看 的..,
epoll详细工作原理.docx
04-29
epoll 工作原理详解 epoll 是一种高效的 IO 多路复用技术，可以处理数以百万计的 socket 句柄。它的高效性来自于其巧妙的设计和实现。下面我们将深入探讨 epoll 的工作原理。 epoll_create epoll_create 是建立一...
linux socket NIO epoll教程参数讲解.zip
12-12
大并发服务器编程模型 windows iocp完成端口模型可支持1万大并发,但是linux能作到5万大并发
作为C++后端开发程序员，应该彻底理解Epoll实现原理
Linuxhus的博客
02-26 646
这篇文章读不懂的没关系，可以先收藏一下。 当然，这些核心思想，也会在之后的文章中慢慢做详细讲解，欢迎关注。 文章如果实在是没有看懂，可以回头来看看这个视频讲解：epoll原理剖析 epoll是Linux平台下的一种特有的多路复用IO实现方式，与传统的select相比，epoll在性能上有很大的提升。本文主要讲解epoll的实现原理，而对于epoll的使用可以参考相关的书籍或文章。 epoll 的创建 要使用epoll首先需要调用epoll_create()函数创建一个ep...
[c++] 学习epoll的历程(附调试用demo)
sszzyzzy的博客
05-08 1601
最近在看epoll查阅了很多文章，，，之所以不好理解是因为涉及到的东西太多组合方式也各不一样，在此处罗列一下。。。 两个fd 一个是 listenfd=socket(…) 得到的，用来监听socket的fd 另一个是 connfd=accpt(…) 得到的，用来交互数据的fd，是在有cli连接到socket的时候生成的 两者不同都要分别进行各自的设置 两种状态 阻塞与非阻塞 这个是针对fd进行的设...
EPOLLIN , EPOLLOUT , EPOLLPRI, EPOLLERR 和 EPOLLHUP事件
热门推荐
yingying.liu的专栏
03-08 3万+
2.。。 1、listen fd，有新连接请求，对端发送普通数据 触发EPOLLIN。 2、带外数据，只触发EPOLLPRI。 3、对端正常关闭（程序里close()，shell下kill或ctr+c），触发EPOLLIN和EPOLLRDHUP，但是不触发EPOLLERR 和EPOLLHUP。 再man epoll_ctl看下后两个事件的说明，这两个应该是本端（server端）出错才触发的
【Linux学习】epoll详解
844604778
07-05 1978
什么是epoll epoll是什么？按照man手册的说法：是为处理大批量句柄而作了改进的poll。当然，这不是2.6内核才有的，它是在2.5.44内核中被引进的(epoll(4) is a new API introduced in Linux kernel 2.5.44)，它几乎具备了之前所说的一切优点，被公认为Linux2.6下性能最好的多路I/O就绪通知方法。 epoll的相关系...
linux epoll原理
03-16
Linux epoll是一种高效的I/O事件通知机制，它可以监视多个文件描述符，当其中任意一个文件描述符上有事件发生时，就会通知应用程序进行处理。epoll采用了事件驱动的方式，可以大大提高I/O操作的效率和响应速度。它的原理是通过内核维护一个事件表，将需要监视的文件描述符添加到事件表中，并设置相应的事件类型。当有事件发生时，内核会将事件信息添加到一个就绪列表中，应用程序可以通过epoll_wait函数获取就绪列表中的事件信息进行处理。相比于传统的select和poll机制，epoll具有更高的并发性和可扩展性，可以处理更多的连接和更大的数据量。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值