Epoll的使用详解（转）

最新推荐文章于 2024-09-05 10:18:25 发布
最新推荐文章于 2024-09-05 10:18:25 发布
阅读量445 收藏 2
点赞数
分类专栏： 网络编程 文章标签： epoll
本文详细介绍了Epoll的工作原理，包括边缘触发和水平触发模式，以及Epoll的API使用方法，如epoll_create(), epoll_ctl(), 和 epoll_wait()。通过官方示例和一个完整的可运行DEMO，展示了如何在Linux环境下使用Epoll进行高效的I/O多路复用。
摘要由CSDN通过智能技术生成

转自：https://www.jianshu.com/p/ee381d365a29

1.Epoll简介

EPOLL 的API用来执行类似poll()的任务。能够用于检测在多个文件描述符中任何IO可用的情况。Epoll API可以用于边缘触发(edge-triggered)和水平触发(level-triggered), 同时epoll可以检测更多的文件描述符。以下的系统调用函数提供了创建和管理epoll实例：

  • epoll_create() 可以创建一个epoll实例并返回相应的文件描述符(epoll_create1() 扩展了epoll_create() 的功能)。
  • 注册相关的文件描述符使用epoll_ctl()
  • epoll_wait() 可以用于等待IO事件。如果当前没有可用的事件，这个函数会阻塞调用线程。

边缘触发(edge-triggered 简称ET)和水平触发(level-triggered 简称LT)：

epoll的事件派发接口可以运行在两种模式下：边缘触发(edge-triggered)和水平触发(level-triggered)，两种模式的区别请看下面,我们先假设下面的情况：

  1. 一个代表管道读取的文件描述符已经注册到epoll实例上了。
  2. 在管道的写入端写入了2kb的数据。
  3. epoll_wait 返回一个可用的rfd文件描述符。
  4. 从管道读取了1kb的数据。
  5. 调用epoll_wait 完成。

如果rfd被设置了ET，在调用完第五步的epool_wait 后会被挂起，尽管在缓冲区还有可以读取的数据，同时另外一段的管道还在等待发送完毕的反馈。这是因为ET模式下只有文件描述符发生改变的时候，才会派发事件。所以第五步操作，可能会去等待已经存在缓冲区的数据。在上面的例子中，一个事件在第二步被创建，再第三步中被消耗，由于第四步中没有读取完缓冲区，第五步中的epoll_wait可能会一直被阻塞下去。

下面情况下推荐使用ET模式:

  1. 使用非阻塞的IO。
  2. epoll_wait() 只需要在read或者write返回的时候。

相比之下，当我们使用LT的时候（默认）,epoll会比poll更简单更快速，而且我们可以使用在任何一个地方。

2.API介绍

先简单的看下EPOLL的API

2.1 创建epoll

#include <sys/epoll.h>

int epoll_create(int size);
int epoll_create1(int flags);

epoll_create() 可以创建一个epoll实例。在linux 内核版本大于2.6.8 后，这个size 参数就被弃用了，但是传入的值必须大于0。

在 epoll_create () 的最初实现版本时， size参数的作用是创建epoll实例时候告诉内核需要使用多少个文件描述符。内核会使用 size 的大小去申请对应的内存(如果在使用的时候超过了给定的size， 内核会申请更多的空间)。现在，这个size参数不再使用了（内核会动态的申请需要的内存）。但要注意的是，这个size必须要大于0，为了兼容旧版的linux 内核的代码。

epoll_create() 会返回新的epoll对象的文件描述符。这个文件描述符用于后续的epoll操作。如果不需要使用这个描述符，请使用close关闭。

epoll_create1() 如果flags的值是0，epoll_create1()等同于epoll_create()除了过时的size被遗弃了。当然flags可以使用 EPOLL_CLOEXEC，请查看 open() 中的O_CLOEXEC来查看 EPOLL_CLOEXEC有什么用。

返回值: 如果执行成功，返回一个非负数(实际为文件描述符), 如果执行失败，会返回-1，具体原因请查看error.

2.2 设置epoll事件

#include <sys/epoll.h>

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

这个系统调用能够控制给定的文件描述符epfd指向的epoll实例，op是添加事件的类型，fd是目标文件描述符。

有效的op值有以下几种：

  • EPOLL_CTL_ADD 在epfd中注册指定的fd文件描述符并能把event和fd关联起来。
  • EPOLL_CTL_MOD 改变fd和event之间的联系。
  • EPOLL_CTL_DEL 从指定的epfd中删除fd文件描述符。在这种模式中event是被忽略的，并且为可以等于NULL。

event这个参数是用于关联制定的fd文件描述符的。它的定义如下：

typedef union epoll_data {
    void        *ptr;
    int          fd;
    uint32_t     u32;
    uint64_t     u64;
} epoll_data_t;

struct epoll_event {
    uint32_t     events;      /* Epoll events */
    epoll_data_t data;        /* User data variable */
};

events这个参数是一个字节的掩码构成的。下面是可以用的事件：

  • EPOLLIN - 当关联的文件可以执行 read ()操作时。
  • EPOLLOUT - 当关联的文件可以执行 write ()操作时。
  • EPOLLRDHUP - (从 linux 2.6.17 开始)当socket关闭的时候，或者半关闭写段的(当使用边缘触发的时候，这个标识在写一些测试代码去检测关闭的时候特别好用)
  • EPOLLPRI - 当 read ()能够读取紧急数据的时候。
  • EPOLLERR - 当关联的文件发生错误的时候，epoll_wait() 总是会等待这个事件，并不是需要必须设置的标识。
  • EPOLLHUP - 当指定的文件描述符被挂起的时候。epoll_wait() 总是会等待这个事件，并不是需要必须设置的标识。当socket从某一个地方读取数据的时候(管道或者socket),这个事件只是标识出这个已经读取到最后了(EOF)。所有的有效数据已经被读取完毕了，之后任何的读取都会返回0(EOF)。
  • EPOLLET - 设置指定的文件描述符模式为边缘触发，默认的模式是水平触发。
  • EPOLLONESHOT - (从 linux 2.6.17 开始)设置指定文件描述符为单次模式。这意味着，在设置后只会有一次从epoll_wait() 中捕获到事件，之后你必须要重新调用 epoll_ctl() 重新设置。

返回值：如果成功，返回0。如果失败，会返回-1， errno将会被设置

有以下几种错误：

  • EBADF - epfd 或者 fd 是无效的文件描述符。
  • EEXIST - op是EPOLL_CTL_ADD，同时 fd 在之前，已经被注册到epoll中了。
  • EINVAL - epfd不是一个epoll描述符。或者fd和epfd相同，或者op参数非法。
  • ENOENT - op是EPOLL_CTL_MOD或者EPOLL_CTL_DEL，但是fd还没有被注册到epoll上。
  • NOMEM - 内存不足。
  • EPERM - 目标的fd不支持epoll。

2.3 等待epoll事件

#include <sys/epoll.h> 

int epoll_wait(int epfd, struct epoll_event *events,
                      int maxevents, int timeout); 

int epoll_pwait(int epfd, struct epoll_event *events,
                      int maxevents, int timeout,
                      const sigset_t *sigmask);

epoll_wait 这个系统调用是用来等待epfd中的事件。events指向调用者可以使用的事件的内存区域。maxevents告知内核有多少个events，必须要大于0.

timeout这个参数是用来制定epoll_wait 会阻塞多少毫秒，会一直阻塞到下面几种情况：

  1. 一个文件描述符触发了事件。
  2. 被一个信号处理函数打断，或者timeout超时。

当timeout等于-1的时候这个函数会无限期的阻塞下去，当timeout等于0的时候，就算没有任何事件，也会立刻返回。

struct epoll_event 如下定义:

typedef union epoll_data {
    void    *ptr;
    int      fd;
    uint32_t u32;
    uint64_t u64;
} epoll_data_t;

struct epoll_event {
    uint32_t     events;    /* Epoll events */
    epoll_data_t data;      /* User data variable */
};

每次epoll_wait() 返回的时候，会包含用户在epoll_ctl中设置的events。

还有一个系统调用epoll_pwait ()。epoll_pwait()和epoll_wait ()的关系就像select()和 pselect()的关系。和pselect()一样，epoll_pwait()可以让应用程序安全的等待知道某一个文件描述符就绪或者捕捉到信号。

下面的 epoll_pwait () 调用：

ready = epoll_pwait(epfd, &events, maxevents, timeout, &sigmask);

在内部等同于:

pthread_sigmask(SIG_SETMASK, &sigmask, &origmask);
ready = epoll_wait(epfd, &events, maxevents, timeout);
pthread_sigmask(SIG_SETMASK, &origmask, NULL);

如果 sigmask为NULL, epoll_pwait()等同于epoll_wait()。

返回值：有多少个IO事件已经准备就绪。如果返回0说明没有IO事件就绪，而是timeout超时。遇到错误的时候，会返回-1，并设置 errno。

有以下几种错误:

  • EBADF - epfd是无效的文件描述符
  • EFAULT - 指针events指向的内存没有访问权限
  • EINTR - 这个调用被信号打断。
  • EINVAL - epfd不是一个epoll的文件描述符，或者maxevents小于等于0

3.官方demo

#define MAX_EVENTS 10
struct epoll_event  ev, events[MAX_EVENTS];
int         listen_sock, conn_sock, nfds, epollfd;


/* Code to set up listening socket, 'listen_sock',
 * (socket(), bind(), listen()) omitted */

epollfd = epoll_create1( 0 );
if ( epollfd == -1 )
{
    perror( "epoll_create1" );
    exit( EXIT_FAILURE );
}

ev.events   = EPOLLIN;
ev.data.fd  = listen_sock;
if ( epoll_ctl( epollfd, EPOLL_CTL_ADD, listen_sock, &ev ) == -1 )
{
    perror( "epoll_ctl: listen_sock" );
    exit( EXIT_FAILURE );
}

for (;; )
{
    nfds = epoll_wait( epollfd, events, MAX_EVENTS, -1 );
    if ( nfds == -1 )
    {
        perror( "epoll_wait" );
        exit( EXIT_FAILURE );
    }

    for ( n = 0; n < nfds; ++n )
    {
        if ( events[n].data.fd == listen_sock )
        {
            conn_sock = accept( listen_sock,
                        (struct sockaddr *) &local, &addrlen );
            if ( conn_sock == -1 )
            {
                perror( "accept" );
                exit( EXIT_FAILURE );
            }
            setnonblocking( conn_sock );
            ev.events   = EPOLLIN | EPOLLET;
            ev.data.fd  = conn_sock;
            if ( epoll_ctl( epollfd, EPOLL_CTL_ADD, conn_sock,
                    &ev ) == -1 )
            {
                perror( "epoll_ctl: conn_sock" );
                exit( EXIT_FAILURE );
            }
        } else {
            do_use_fd( events[n].data.fd );
        }
    }
}

4.完整可运行的DEMO

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

#define MAX_EVENT 20
#define READ_BUF_LEN 256

/**
 * 设置 file describe 为非阻塞模式
 * @param fd 文件描述
 * @return 返回0成功，返回-1失败
 */
static int make_socket_non_blocking (int fd) {
    int flags, s;
    // 获取当前flag
    flags = fcntl(fd, F_GETFL, 0);
    if (-1 == flags) {
        perror("Get fd status");
        return -1;
    }

    flags |= O_NONBLOCK;

    // 设置flag
    s = fcntl(fd, F_SETFL, flags);
    if (-1 == s) {
        perror("Set fd status");
        return -1;
    }
    return 0;
}

int main() {
    // epoll 实例 file describe
    int epfd = 0;
    int listenfd = 0;
    int result = 0;
    struct epoll_event ev, event[MAX_EVENT];
    // 绑定的地址
    const char * const local_addr = "192.168.0.45";
    struct sockaddr_in server_addr = { 0 };

    listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == listenfd) {
        perror("Open listen socket");
        return -1;
    }
    /* Enable address reuse */
    int on = 1;
    // 打开 socket 端口复用, 防止测试的时候出现 Address already in use
    result = setsockopt( listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on) );
    if (-1 == result) {
        perror ("Set socket");
        return 0;
    }

    server_addr.sin_family = AF_INET;
    inet_aton (local_addr, &(server_addr.sin_addr));
    server_addr.sin_port = htons(8080);
    result = bind(listenfd, (const struct sockaddr *)&server_addr, sizeof (server_addr));
    if (-1 == result) {
        perror("Bind port");
        return 0;
    }
    result = make_socket_non_blocking(listenfd);
    if (-1 == result) {
        return 0;
    }

    result = listen(listenfd, 200);
    if (-1 == result) {
        perror("Start listen");
        return 0;
    }

    // 创建epoll实例
    epfd = epoll_create1(0);
    if (1 == epfd) {
        perror("Create epoll instance");
        return 0;
    }

    ev.data.fd = listenfd;
    ev.events = EPOLLIN | EPOLLET /* 边缘触发选项。 */;
    // 设置epoll的事件
    result = epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);

    if(-1 == result) {
        perror("Set epoll_ctl");
        return 0;
    }

    for ( ; ; ) {
        int wait_count;
        // 等待事件
        wait_count = epoll_wait(epfd, event, MAX_EVENT, -1);

        for (int i = 0 ; i < wait_count; i++) {
            uint32_t events = event[i].events;
            // IP地址缓存
            char host_buf[NI_MAXHOST];
            // PORT缓存
            char port_buf[NI_MAXSERV];

            int __result;
            // 判断epoll是否发生错误
            if ( events & EPOLLERR || events & EPOLLHUP || (! events & EPOLLIN)) {
                printf("Epoll has error\n");
                close (event[i].data.fd);
                continue;
            } else if (listenfd == event[i].data.fd) {
                // listen的 file describe 事件触发， accpet事件

                for ( ; ; ) { // 由于采用了边缘触发模式，这里需要使用循环
                    struct sockaddr in_addr = { 0 };
                    socklen_t in_addr_len = sizeof (in_addr);
                    int accp_fd = accept(listenfd, &in_addr, &in_addr_len);
                    if (-1 == accp_fd) {
                        perror("Accept");
                        break;
                    }
                    __result = getnameinfo(&in_addr, sizeof (in_addr),
                                           host_buf, sizeof (host_buf) / sizeof (host_buf[0]),
                                           port_buf, sizeof (port_buf) / sizeof (port_buf[0]),
                                           NI_NUMERICHOST | NI_NUMERICSERV);

                    if (! __result) {
                        printf("New connection: host = %s, port = %s\n", host_buf, port_buf);
                    }

                    __result = make_socket_non_blocking(accp_fd);
                    if (-1 == __result) {
                        return 0;
                    }

                    ev.data.fd = accp_fd;
                    ev.events = EPOLLIN | EPOLLET;
                    // 为新accept的 file describe 设置epoll事件
                    __result = epoll_ctl(epfd, EPOLL_CTL_ADD, accp_fd, &ev);

                    if (-1 == __result) {
                        perror("epoll_ctl");
                        return 0;
                    }
                }
                continue;
            } else {
                // 其余事件为 file describe 可以读取
                int done = 0;
                // 因为采用边缘触发，所以这里需要使用循环。如果不使用循环，程序并不能完全读取到缓存区里面的数据。
                for ( ; ;) {
                    ssize_t result_len = 0;
                    char buf[READ_BUF_LEN] = { 0 };

                    result_len = read(event[i].data.fd, buf, sizeof (buf) / sizeof (buf[0]));

                    if (-1 == result_len) {
                        if (EAGAIN != errno) {
                            perror ("Read data");
                            done = 1;
                        }
                        break;
                    } else if (! result_len) {
                        done = 1;
                        break;
                    }

                    write(STDOUT_FILENO, buf, result_len);
                }
                if (done) {
                    printf("Closed connection\n");
                    close (event[i].data.fd);
                }
            }
        }

    }
    close (epfd);
    return 0;
}

参考资料：
https://www.jianshu.com/p/ee381d365a29

mayue_csdn
关注
专栏目录
epoll使用详解
06-13
在linux的网络编程中，很长的时间都在使用select来做事件触发。在linux新的内核中，有了一种替换它的机制，就是epoll。 相比于select，epoll最大的好处在于它不会随着监听fd数目的增长而降低效率。因为在内核中的select实现中，它是采用轮询来处理的，轮询的fd数目越多，自然耗时越多。并且，在linux/posix_types.h头文件有这样的声明： #define __FD_SETSIZE 1024 表示select最多同时监听1024个fd，当然，可以通过修改头文件再重编译内核来扩大这个数目，但这似乎并不治本。
Epoll的使用详解
Michael的博客
02-24 4027
1.EPOLL简介 EPOLL 的API用来执行类似poll()的任务。能够用于检测在多个文件描述符中任何IO可用的情况。Epoll API可以用于边缘触发(edge-triggered)和水平触发(level-triggered), 同时epoll可以检测更多的文件描述符。以下的系统调用函数提供了创建和管理epoll实例： epoll_create() 可以创建一个epoll实例并返回相应
Linux编程系列——epoll的使用详解（带实现案例）
最新发布
weixin_58284606的博客
09-05 840
epoll函数详解（带案例）
Linux 2.6内核中提高网络I/O性能的新方法-epoll
legion8169的专栏
06-01 1113
Linux 2.6内核中提高网络I/O性能的新方法epoll正如我昨天在“Linux下各类TCP网络服务器的实现源代码”(http://zhoulifa.bokee.com/5345930.html)一文中提到的那样，I/O多路复用技术在比较多的TCP网络服务器中有使用，即比较多的用到select函数。感谢chinaunix.net上朋友safedead(http://bbs.chinauni
epoll使用
永远在跟随，从未去超越
04-08 6497
epoll使用        epoll的工作原理是，你如果想进行IO操作时，先向epoll查询是否可读或可写，如果处于可读或可写状态后，epoll会通过epoll_wait函数通知你，此时你再进行进一步的recv或send操作。        epoll仅仅是一个异步事件的通知机制，其本身并不作任何的IO读写操作，它只负责告诉你是不是可以读或可以写了，而具体的读写操作，还要应用层自己
linux epoll机制详解
09-15
默认情况下，epoll使用LT模式，这意味着只要文件描述符处于就绪状态，每次epoll_wait都会报告该事件，直到应用处理完。而ET模式下，epoll只会在事件状态改变时报告一次，即使在事件处理过程中，文件描述符仍然就绪，...
Epoll模型详解
01-05
### Epoll模型详解 #### 一、Epoll概述 在Linux网络编程中，早期广泛使用的事件触发机制主要是基于`select`。然而随着技术的发展以及应用需求的提高，`select`逐渐暴露出了一些明显的局限性，比如它对于大量文件...
Epoll模型详解.pdf
10-08
《Epoll模型详解》 Epoll是Linux内核提供的一种高效、可扩展的I/O事件通知机制，尤其在处理大量并发连接时表现出显著优势。它替代了传统的select和poll方法，解决了这些方法在处理大量文件描述符（fd）时效率低下的...
【epoll】epoll使用详解（精髓）--研读和修正
热门推荐
bandaoyu的note
04-26 1万+
目录 目录 epoll - I/O epoll的接口 关于ET、LT两种工作模式 epoll程序框架 实例源码 编译命令 命令行简单测试 相关知识 Socket的阻塞模式和非阻塞模式 如何动态的改变listen监听的个数呢？ 队列已满的情况，如何处理？ SYN泛滥攻击 参考 代码二，多进程Epoll： 建立2000+个链接的测试代码 epoll - I/O ...
epoll 使用详解（精髓）
关注微信公众号【开源Linux】，后台回复『10T』，领取10T学习资源大放送，涵盖Linux、虚拟化、容器、云计算、网络、Python、Go等书籍和视频
10-27 553
epoll和select相比于select，epoll最大的好处在于它不会随着监听fd数目的增长而降低效率。因为在内核中的select实现中，它是采用轮询来处理的，轮询的fd数目越多，自然耗时越多。并且，在linux/posix_types.h头文件有这样的声明：#define __FD_SETSIZE 1024表示select最多同时监听1024个fd，当然，可以通过修改头文件再重编译内核来扩大...
epoll使用方法
06-27
epoll函数在server端和client端的使用方法
我读过的最好的epoll讲解--转自”知乎“
weixin_34015336的博客
06-05 9222
作者：蓝形参，Geek 伪技术宅    首先我们来定义流的概念，一个流可以是文件，socket，pipe等等可以进行I/O操作的内核对象。    不管是文件，还是套接字，还是管道，我们都可以把他们看作流。    之后我们来讨论I/O的操作，通过read，我们可以从流中读入数据；通过write，我们可以往流写入数据。现在假定一个情形，我们需要从流中读数据，但是流中还没有数据，（典型的例子为，客户端要...
epoll使用详解（精髓）
XMJYever的博客
09-28 1073
epoll - I/O event notification facility 在linux的网络编程中，很长的时间都在使用select来做事件触发。在linux新的内核中，有了一种替换它的机制，就是epoll。 相比于select，epoll最大的好处在于它不会随着监听fd数目的增长而降低效率。因为在内核中的select实现中，它是采用轮询来处理的，轮询的fd数目越多，自然耗时越多。并且，在linux/posix_types.h头文件有这样的声明： #define __FD_SETSIZE 1024
epoll基本使用
j5856004的博客
07-27 1475
epoll简介 epoll是Linux中的一种使用IO多路复用机制，即使用单个线程就可以监听多个文件描述符的读写事件，避免开启大量线程或者执行大量轮询的造成的不必要的性能开销。类似的机制还有select和poll，关于其区别参考。 高性能IO模型分析-浅析Select、Poll、Epoll机制（三） - 知乎 (zhihu.com) 头文件和API #include <sys/epoll.h> // 创建epoll，通常使用epoll_create即可，epoll_create1可以设置一些
【epoll的使用】
qq_43899283的博客
04-17 1444
epoll的使用epoll的作用：（实现I/O的多路复用）epoll操作的相关函数实际案例   本文整理了epoll相关的知识点以供后续的学习和查阅。 epoll的作用：（实现I/O的多路复用）   多路复用I/O就是我们说的select，poll，epoll等操作，复用的好处就在于单个进程就可以同时处理 多个 网络连接的I/O，能实现这种功能的原理就是select、poll、epoll等函数会不断的 轮询它们所负责的所有 socket ，当某个socket有数据到达了，就通知用户进程。   在linux的
epoll简单使用
m0_63440562的博客
07-06 677
是 Linux 系统提供的一种高效的事件通知机制，用于处理大量的并发连接。它可以用于监视多个文件描述符（sockets、文件、管道等）上的事件，并在有事件发生时通知应用程序进行相应的处理。处理事件：根据返回的文件描述符和事件类型，应用程序可以执行相应的操作。例如，如果返回的事件类型是可读事件，可以使用。函数等待事件的发生。可以指定要监视的事件类型，如可读事件、可写事件等。实例中的文件描述符的监视状态。函数会返回触发事件的文件描述符和事件类型。更新事件：在处理完一个事件后，可以使用。实例中删除文件描述符。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值