epoll学习笔记1

最新推荐文章于 2024-07-07 15:35:32 发布
最新推荐文章于 2024-07-07 15:35:32 发布
阅读量832 收藏 1
点赞数
分类专栏： linux c io 文章标签： 网络 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxc3590235/article/details/109603834
版权
linux 同时被 3 个专栏收录
8 篇文章 0 订阅
订阅专栏
c
3 篇文章 0 订阅
订阅专栏
io
3 篇文章 0 订阅
订阅专栏

简介

epoll是同poll相似的，用于同时监听多个fd上的相关I/O事件。epoll相较于poll而言有边缘触发和水平触发两种事件触发模式，poll只有水平触发一种事件触发模式。

事件触发模式介绍

水平触发

水平触发（Level-Triggered）是当被监控的fd上有可读写事件发生时，epoll_wait会通知程序去读写。如果程序在这次操作没有将数据全部读写完（可能由于缓冲区不够），那么下次调用epoll_wait时仍然会通知程序去读写，直到数据被读写完为止。
优点： 开发时每次读写操作只需要读写想要的数据量即可，这样可以每次事件触发执行一个操作。
缺点： 如果系统中有大量不需要读写的fd时，每次epoll_wait都会返回，效率会很低。

边缘触发

边缘触发（Edge-Triggered）是当被监控的fd上有可读写事件发生时，epoll_wait会通知程序去读写。如果程序在这次操作没有将数据全部读写完（可能由于缓冲区不够），那么下次调用epoll_wait时将不会再通知程序去读写（即：只通知一次）。直到该被监控fd上第二次出现可读写事件时，epoll_wait才会通知程序去读写。
优点： 如果系统中有大量不需要读写fd时，不用每次epoll_wait返回时都会返回，相比水平触发效率更高。
缺点： 如果没有一次性将数据全部读写完，则不会再收到事件通知。

相关结构体介绍

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 */
};

event事件

EPOLLIN： 和fd相关联的读操作事件。
EPOLLOUT： 和fd关联的写操作事件。
EPOLLRDHUP： 和fd关联的读挂起事件。在流式socket的通信对端关闭了连接，或关闭了一半的写操作。
EPOLLPRI： 和fd关联的紧急数据的读操作事件。
EPOLLERR： 和fd关联的错误事件。
EPOLLHUP： 和fd关联的挂起事件。
EPOLLET： 设置fd触发方式为边缘触发。默认为水平触发。
EPOLLONESHOT： 设置fd的事件只触发一次。在一次epoll_wait报告该fd关联事件后，系统将禁止报告该fd关联的事件，必须通过epoll_ctl的EPOLL_CTL_MOD方法重新设置fd的事件触发。

依赖头文件

#include <sys/epoll.h>

相关函数介绍

epoll_create

int epoll_create(int size);

创建一个epoll实例，返回标识该epoll实例的fd。该fd将用于epoll_wait/epoll_pwait/epoll_ctl等操作的第一个参数。
参数
size： linux2.6.8后该参数将会被忽略，但是必须大于0。
返回值
成功返回一个非负的fd，该fd将于epoll_wait等接口。失败返回-1，错误码在errno中。

epoll_create1

 int epoll_create1(int flags);

创建一个epoll实例，返回标识该epoll实例的fd。该fd将用于epoll_wait/epoll_pwait/epoll_ctl等操作的第一个参数。
参数
flags： 为0，则效果等同于epoll_create；为EPOLL_CLOEXEC，则会将fd设置为close-on-exec（即：在fd上设置FD_CLOEXEC标识）。
返回值
成功返回一个非负的fd，该fd将于epoll_wait等接口。失败返回-1，错误码在errno中。

epoll_ctl

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

对epoll实例执行相应的控制操作。
参数
epfd： 和epoll实例关联的fd。
op： 操作的操作码。取值有：EPOLL_CTL_ADD、EPOLL_CTL_MOD、EPOLL_CTL_DEL。
fd： 执行操作应用的fd。
event： 执行操作应用fd对应的事件信息。
返回值
成功返回0。失败返回-1，错误码在errno中。

epoll_wait

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

等待epoll实例中关联的fd上的相关事件被触发，或超时时返回。
参数
epfd： 和epoll实例关联的fd。
events： struct epoll_event结构体数组，用于接收epoll关联fd的事件信息。
maxevents： events的数组大小。
timeout： 等待超时时间，单位毫秒。等于-1表示一直等待。

epoll_pwait

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

作用同epoll_wait，只是可以设置允许捕捉的信号。
参数
epfd： 和epoll实例关联的fd。
events： struct epoll_event结构体数组，用于接收epoll关联fd的事件信息。
maxevents： events的数组大小。
timeout： 等待超时时间，单位毫秒。等于-1表示一直等待。
sigmask： 信号信息掩码。

示例

代码

服务端

源文件名称：epoll_server.c

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

static void
epoll_addfd_read(int efd, int fd)
{
    int flags = fcntl(fd, F_GETFL);
    fcntl(fd, F_SETFL, flags | O_NONBLOCK);
    struct epoll_event ep_event;
    //ep_event.events = EPOLLIN;
    ep_event.events = EPOLLIN | EPOLLET;
    ep_event.data.fd = fd;
    epoll_ctl(efd, EPOLL_CTL_ADD, fd, &ep_event);
}

static void
epoll_removefd(int efd, int fd)
{
    epoll_ctl(efd, EPOLL_CTL_DEL, fd, NULL);
    close(fd);
}

static void
do_read(int efd, int fd)
{
    char buf[1024];
    ssize_t rlen;
    int trycnt = 0;
    while(1) {
        rlen = read(fd, buf, sizeof(buf));
        if (rlen >= 0) {
            if (rlen == 0) {
                printf("connection already close by peer. fd:%d\n", fd);
                epoll_removefd(efd, fd);
                break;
            }
            printf("recv len:%ld. fd:%d\n", rlen, fd);
            trycnt = 0;
            /*
            if (rlen < sizeof(buf)) {
                break;
            }
            */
        } else {
            if (errno == EAGAIN || errno == EWOULDBLOCK) {
                if (trycnt >= 5) {
                    printf("try read again trycnt >= 5 break out, fd:%d\n", fd);
                    break;
                }
                printf("need read again. fd:%d, trycnt:%d\n", fd, ++trycnt);
            } else {
                printf("read failed. errno:%d, errstr:%s, fd:%d\n", errno, strerror(errno), fd);
                if (errno == ECONNRESET || errno == ENOTCONN) {
                    printf("connection already close by peer. fd:%d\n", fd);
                    epoll_removefd(efd, fd);
                }
                break;
            }
        }
    }
}

static int
do_process(int efd, int listenfd)
{
    struct epoll_event events[8], *event;
    int fd;
    int num = epoll_wait(efd, events, sizeof(events), 1000);
    if (num < 0) {
        printf("epoll_wait failed. errstr:%s\n", strerror(errno));
        return -1;
    } else if (num == 0) {
        printf("epoll_wait timeout\n");
        return 0;
    }
    int i;
    for (i = 0; i < num; ++i) {
        event = &events[i];
        fd = event->data.fd;
        if (fd == listenfd) {
            struct sockaddr_storage caddr;
            socklen_t caddrlen = sizeof(caddr);
            int fd = accept(listenfd, (struct sockaddr *)&caddr, &caddrlen);
            if (fd > 0) {
                epoll_addfd_read(efd, fd);
                if (caddr.ss_family != AF_INET && caddr.ss_family != AF_INET6) {
                    printf("Unsupport family:%d\n", caddr.ss_family);
                } else {
                    char caddr_str[128] = {0};
                    uint16_t port;
                    if (caddr.ss_family == AF_INET) {
                        struct sockaddr_in *addr4 = (struct sockaddr_in *)&caddr;
                        inet_ntop(AF_INET, (const void *)&(addr4->sin_addr.s_addr), caddr_str, sizeof(caddr_str));
                        port = ntohs(addr4->sin_port);
                    } else {
                        struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&caddr;
                        inet_ntop(AF_INET6, (const void *)&(addr6->sin6_addr), caddr_str, sizeof(caddr_str));
                        port = ntohs(addr6->sin6_port);
                    }
                    printf("A new connection(%d) from %s#%u\n", fd, caddr_str, port);
                }
            } else {
                printf("accept call failed. errstr:%s, listenfd:%d\n", strerror(errno), listenfd);
            }
        } else {
            do_read(efd, fd);
        }
    }
    return 0;
}

static int
create_tcp_server(const char *ip, const uint16_t port, const bool ipv6)
{
    const struct sockaddr *addr;
    socklen_t addrlen;
    struct sockaddr_in addr4;
    struct sockaddr_in6 addr6;
    int family;
    if (ipv6) {
        memset(&addr6, 0, sizeof(addr6));
        addr6.sin6_family = AF_INET6;
        addr6.sin6_port = htons(port);
        if (inet_pton(AF_INET6, ip, &addr6.sin6_addr) == -1) {
            printf("inet_pton failed for ipv6. ip:%s, port:%u, errstr:%s\n", ip, port, strerror(errno));
            return -1;
        }
        addr = (const struct sockaddr *)&addr6;
        addrlen = sizeof(addr6);
        family = AF_INET6;
    } else {
        memset(&addr4, 0, sizeof(addr4));
        addr4.sin_family = AF_INET;
        addr4.sin_port = htons(port);
        if (inet_pton(AF_INET, ip, &addr4.sin_addr.s_addr) == -1) {
            printf("inet_pton failed for ipv4. ip:%s, port:%u, errstr:%s\n", ip, port, strerror(errno));
            return -1;
        }
        addr = (const struct sockaddr *)&addr4;
        addrlen = sizeof(addr4);
        family = AF_INET;
    }
    int fd = socket(family, SOCK_STREAM, 0);
    if (fd == -1) {
        printf("socket failed. errstr:%s\n", strerror(errno));
        return -1;
    }
    int reuse = 1;
    if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) == -1) {
        close(fd);
        printf("setsockopt for SO_REUSEADDR failed. errstr:%s\n", strerror(errno));
        return -1;
    }
    if (bind(fd, addr, addrlen) == -1) {
        close(fd);
        printf("bind failed. errstr:%s\n", strerror(errno));
        return -1;
    }
    if (listen(fd, 5) == -1) {
        close(fd);
        printf("listen failed. errstr:%s\n", strerror(errno));
        return -1;
    }
    return fd;
}

int
main(int argc, char **argv)
{
    int svrfd = create_tcp_server("127.0.0.1", 5151, false);
    if (svrfd < 0) {
        printf("create_tcp_server failed.\n");
        return -1;
    }
    int efd = epoll_create(1024);
    if (efd == -1) {
        close(svrfd);
        printf("epoll_create failed. errstr:%s\n", strerror(errno));
        return -1;
    }
    epoll_addfd_read(efd, svrfd);
    int ret;
    while (1) {
        ret = do_process(efd, svrfd);
        if (ret != 0) {
            break;
        }
    }
    epoll_removefd(efd, svrfd);
    close(efd);
    return 0;
}

客户端

源文件名称：epoll_client.c

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

static void
do_write(int fd, char *data, size_t dlen)
{
    ssize_t wlen, awlen = 0;
    int trycnt = 0;
    while (awlen < dlen) {
        wlen = write(fd, (const void *)(data+awlen), dlen-awlen);
        if (wlen == -1) {
            if (errno == EAGAIN || errno == EWOULDBLOCK) {
                if (trycnt >= 5) {
                    printf("try write again trycnt >= 5 break out. fd:%d\n", fd);
                    break;
                }
                printf("need write again. fd:%d, trycnt:%d\n", fd, ++trycnt);
            } else {
                printf("write failed. errstr:%s, fd:%d\n", strerror(errno), fd);
                break;
            }
        } else {
            awlen += wlen;
            trycnt = 0;
            printf("write succeed. fd:%d, wlen:%ld, awlen:%ld, dlen:%ld\n", fd, wlen, awlen, dlen);
        }
    }
}

static int
create_tcp_client(const char *ip, const uint16_t port, const bool ipv6)
{
    const struct sockaddr *addr;
    socklen_t addrlen;
    struct sockaddr_in addr4;
    struct sockaddr_in6 addr6;
    int family;
    if (ipv6) {
        memset(&addr6, 0, sizeof(addr6));
        addr6.sin6_family = AF_INET6;
        addr6.sin6_port = htons(port);
        if (inet_pton(AF_INET6, ip, &addr6.sin6_addr) == -1) {
            printf("inet_pton failed for ipv6. ip:%s, port:%u, errstr:%s\n", ip, port, strerror(errno));
            return -1;
        }
        addr = (const struct sockaddr *)&addr6;
        addrlen = sizeof(addr6);
        family = AF_INET6;
    } else {
        memset(&addr4, 0, sizeof(addr4));
        addr4.sin_family = AF_INET;
        addr4.sin_port = htons(port);
        if (inet_pton(AF_INET, ip, &addr4.sin_addr.s_addr) == -1) {
            printf("inet_pton failed for ipv4. ip:%s, port:%u, errstr:%s\n", ip, port, strerror(errno));
            return -1;
        }
        addr = (const struct sockaddr *)&addr4;
        addrlen = sizeof(addr4);
        family = AF_INET;
    }
    int fd = socket(family, SOCK_STREAM, 0);
    if (fd == -1) {
        printf("socket failed. errstr:%s\n", strerror(errno));
        return -1;
    }
    if (connect(fd, addr, addrlen) == -1) {
        close(fd);
        printf("connect failed. errstr:%s\n", strerror(errno));
        return -1;
    }
    return fd;
}

int
main(int argc, char **argv)
{
    if (argc <= 1) {
        printf("please give send data\n");
        return -1;
    }
    int clifd = create_tcp_client("127.0.0.1", 5151, false);
    if (clifd < 0) {
        printf("create_tcp_client failed.\n");
        return -1;
    }
    int i;
    for (i = 1; i < argc; ++i) {
        do_write(clifd, argv[i], strlen(argv[i]));
    }
    close(clifd);
    return 0;
}

执行结果

客户端

xxxx:~$ ./epoll_client adfdf sdfsdfs sss aaaaaa sdf
write succeed. fd:3, wlen:5, awlen:5, dlen:5
write succeed. fd:3, wlen:7, awlen:7, dlen:7
write succeed. fd:3, wlen:3, awlen:3, dlen:3
write succeed. fd:3, wlen:6, awlen:6, dlen:6
write succeed. fd:3, wlen:3, awlen:3, dlen:3
xxxx:~$

服务端

xxxx:~$ ./epoll_server 
epoll_wait timeout
epoll_wait timeout
epoll_wait timeout
epoll_wait timeout
epoll_wait timeout
epoll_wait timeout
epoll_wait timeout
epoll_wait timeout
epoll_wait timeout
epoll_wait timeout
epoll_wait timeout
A new connection(5) from 127.0.0.1#55275
recv len:24. fd:5
connection already close by peer. fd:5
epoll_wait timeout
epoll_wait timeout
epoll_wait timeout
epoll_wait timeout
epoll_wait timeout
epoll_wait timeout
epoll_wait timeout
epoll_wait timeout
coding快乐
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
EPOLLRDHUP EPOLLHUP 事件
qixiang2013的专栏
08-19 4117
EPOLLRDHUP EPOLLHUP 事件
epoll学习笔记
大冰的小屋
07-21 855
1.内核事件表     epoll是Linux
epoll_pwait
a6d0m5i5n1tw的专栏
03-20 2520
http://man7.org/linux/man-pages/man2/epoll_wait.2.html #include <sys/epoll.h> int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout); ...
timerfd_create 和 epoll_create1
最新发布
luerbing的博客
07-07 839
是Linux系统提供的一种高级定时器接口，它允许应用程序创建一个特殊的文件描述符，该文件描述符可用于监控定时事件。当定时器触发时，内核会向这个文件描述符写入数据，应用程序可以通过读取这个文件描述符来检测定时器是否到期。相比于传统的alarmsetitimer等定时器接口，提供了更高的精度和更好的可移植性。通常和timerfd_settime配合使用。函数创建一个定时器文件描述符，参数表示使用单调时间作为计时基准，标志表示文件描述符为非阻塞模式并在进程退出时自动关闭。函数用于配置定时器，ts。
RST与epoll的EPOLLHUP事件
热门推荐
voidccc的专栏
02-27 1万+
当socket的一端认为对方发来了一个不存在的4元组请求的时候,会回复一个RST响应,在epoll上会响应为EPOLLHUP事件,目前我已知的两种情况会发响应RST [1] 当客户端向一个没有在listen的服务器端口发送的connect的时候 服务器会返回一个RST 因为服务器根本不知道这个4元组的存在  [2] 当已经建立好连接的一对客户端和服务器,客户端突然操作系统崩溃,或者拔掉
epoll详解（使用、原理、实验）
欢迎来到jiantaoyab博客
02-13 5772
执行epoll_create时，创建了红黑树和就绪链表，执行epoll_ctl时，如果增加socket句柄，则检查在红黑树中是否存在，存在立即返回，不存在则添加到树干上，然后向内核注册回调函数，用于当中断事件来临时向准备就绪链表中插入数据。epoll_wait在调用时，在给定的timeout时间内，当在监控的所有句柄中有事件发生时，就返回用户态的进程,不用传递socket句柄给内核，因为内核已经在epoll_ctl中拿到了要监控的句柄列表。，当有的连接请求的时候，服务器被通知，执行回调函数来建立起连接。
epoll精髓
lubosheng的专栏
11-26 279
<br />     在linux的网络编程中，很长的时间都在使用select来做事件触发。在linux新的内核中，有了一种替换它的机制，就是epoll。<br />      相比于select，epoll最大的好处在于它不会随着监听fd数目的增长而降低效率。因为在内核中的select实现中，它是采用轮询来处理的，轮询的fd数目越多，自然耗时越多。并且，在linux/posix_types.h头文件有这样的声明：<br />#define __FD_SETSIZE    1024<br />表示selec
epoll学习记录1
qq_39846745的博客
08-28 162
  下面这段代码来自：https://blog.csdn.net/LEOdabao/article/details/80339574   /*  *使用epoll实现的服务器 */   #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;unistd.h&gt; #include &lt;sys/socket.h&g...
epoll原理学习笔记
jue_1xin的专栏
09-03 1781
epoll是Linux下IO多路复用接口select/poll的增强版本，是linux平台高性能网络IO的必要组件。其有两种实现方式：内核态实现和用户态实现。内核态实现参考代码为fs/eventpoll.c，用户态参考实现代码为https://github.com/wangbojing/NtyTcp/blob/master/src/nty_e poll_rb.c。虽然其实现方式不一样，实现细节有差异，但是原理是一样的。
Android源码 Linux系统调用poll、select、epoll学习笔记
王智博
02-26 815
参考： (源码解读poll/select内核机制)[http://gityuan.com/2019/01/05/linux-poll-select/] (源码解读epoll内核机制)[http://gityuan.com/2019/01/06/linux-epoll/]
Socket编程之epoll的学习笔记
dream0130__的博客
02-27 217
1.内核事件表 epoll是Linux特有的I/O复用函数,首先，epoll使用一组函数来完成任务，而不是单个函数.其次,epoll把用户关心的文件描述符上的事件放在内核里的一个事件表中，epoll需要使用一个额外的文件描述符，来唯一标识内核的这个事件表. #include&lt;sys/epoll.h&gt; int epoll_create(int size) size只是告诉内核，事件表需...
个人对于epollhup的理解
weixin_30675967的博客
05-15 858
　　1.原因 　　　　由于最近对于异步connect函数的测试,发现提前将一个套接字加入epoll监听队列会不断爆出epollhup事件 　　2.示例 　　　　........ 　　　 iEpoll = epoll_create(1); 　　　 iFd = socket(AF_INET, SOCK_STREAM, 0); stEvent.events = EPO...
epoll()无论涉及wait队列分析
weixin_34044273的博客
07-27 135
事件1. epfd-file-&gt;eventpoll-&gt;wq:   struct eventpoll {     ...     wait_queue_head_t wq;     //用于epoll_pwait()事件的等待队列 情况1分析     struct list_head rdllist; //就绪的fd队列 ready list     struct r...
Epoll实验总结
linuxheik的专栏
06-14 371
Epoll实验总结   2012-09-06 15:54:10|  分类： network_program |  标签：epoll  c   |举报 |字号 订阅           下载LOFTER 我的照片书  | 一、超时实验 建立一个阻塞模式的tcp连接到一个没有监听的服务端口（肯定连不上，然后等待超时）
epoll_wait
jfkidear的专栏
09-22 8665
epoll_wait 由 系统机器 于 星期六, 2010/09/18 - 17:43 发表  Linux  man  manual EPOLL_WAIT 章节：Linux 程序员手册 (2) 更新：2010-12-03 到 易美翻译 翻译 本页 名字 epoll_wait, epoll_pwait - 在一个 epoll 文件描述符上等
epoll()涉及到的两种wait队列分析
ordeder的专栏
04-24 7216
主要是等待队列的回调函数用处不同，1的回调是为了唤起处于等待事件而处于休眠的进程，2的回调是为了将epitem中的rdllink结构加入到ready list中。
linux wait 系统调用,epoll_wait 系统调用
weixin_29351351的博客
05-11 316
epoll_wait, epoll_pwait - wait for an I/O event on an epoll filedescriptor以上两个系统调用等待epoll fd上的IO 事件#include int epoll_wait(int epfd, struct epoll_event *events,int maxevents, int timeout);int epo...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值