epoll

最新推荐文章于 2025-05-03 19:36:55 发布
最新推荐文章于 2025-05-03 19:36:55 发布
阅读量101 收藏
点赞数
文章标签： epoll
poll和select相比最大优势在于可以管理更多的文件描述符。
epoll和poll相比最大的有时是速度更快，减少了大量文件描述符从内核到用户态的拷贝。

使用epoll的大体框架是
1 创建epoll instalce，得到epoll的文件描述符
调用epoll_create可以在内核创建一个epoll instance，返回这个instance的文件描述符。size参数已经被忽略了。
       int epoll_create(int size);
       int epoll_create1(int flags);
epoll_create1的参数flags值得一说。它可以取0或者FD_CLOEXEC。如果设置了FD_CLOEXEC，那么epoll_create1返回的文件描述符就会被字段设置FD_CLOEXEC标记。于是当进程以后调用fork的时候，epoll_create1所返回的文件描述符在子进程里是被关闭的，用不了。
例如
int epollfd = epoll_create1(0);

2 利用上面得到的epollfd，添加要监控的文件描述符
struct epoll_event ev;
ev.data.fd = fd;
ev.events = EPOLLIN|EPOLLET;
if(epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &ev) < 0) goto err;
其中：
第一个参数是epoll_create返回的fd
第二个参数是要做的事情，包括：
     EPOLL_CTL_ADD
     EPOLL_CTL_MOD
     EPOLL_CTL_DEL
第三个参数是要监控的fd
第四个参数是struct epoll_event用来描述要监控哪些时间，以及当时间发生时传回哪些数据。

EPOLLIN 表示要监控文件描述符的可读性
epoll_event.data是一个union，除了设置fd，也可以当作void*来使用，执行自定义的数据。当文件描述符准备好时，epoll会把这个指针再“吐出来”。

3 设置好要监控的fd和事件后，就可以等待事件发生了。
struct epoll_event *evs;
evs = calloc(64, sizeof(ev));
while(1)
{
     int n = epoll_wait(epollfd, evs, 64, -1);
     ...
第一个参数是epoll_create返回的文件描述符
第二个参数是提供给epoll_wait的struct epoll_event数组，epoll会把准备好的文件描述符和时间，以及之前ADD时自定义的数放到这个数组里。
第三个参数是数组长度
第四个参数是超时时间
返回值n是此次检测到已就绪的文件描述符数量。之后可以依次取出evs[0]到evs[n-1]来处理。

4 处理得到的struct epoll_event数组
对于数组的每个成员，需要先检查文件描述符发生的什么事件，有没有错误产生。
if(e->events & EPOLLERR || e->events & EPOLLHUP )
....



epoll和poll都是检测文件描述符的缓冲区有没有数据，来判断文件描述符是否准备好了。
但是epoll的事件触发方式更灵活，有边缘触发（ET）和水平触发（LT）两种。
这两个概念和数字电路里的一样。
边缘触发： 当状态从0->1的瞬间触发一次。即缓冲区从空变成有数据的时候返回。
水平触发： 状态为1时始终触发。即只要缓冲区有数据，就会返回。

epoll的默认行为是水平触发，此时的行为和poll一直，就是只要缓冲区有数据没读完，调用epoll就会立刻返回。
边缘触发的性能更好，但是有个问题，就是只当缓冲期从空变成有数据的那一刻触发一次，之后再调用epoll，它就会阻塞，一直等待下一次缓冲区由空到非空的事件。
因此如果需要采用性能更好的边缘触发模式，需要做到以下两点：
1 只支持非阻塞文件描述符，也就是说必须设置NONBLOCK标记。
    int fl = 0;
    int r  = 0;
    if((fl = fcntl(fd, F_GETFL, 0)) < 0) goto err;
    if((r  = fcntl(fd, F_SETFL, fl|O_NONBLOCK)) < 0) goto err;

2 必须确保每一次触发后，都要处理完缓冲区的全部数据。
通常用一个while(1)来解决。
由于已经将文件描述符设置为NONBLOCK了，因此可以用死循环。
如果返回-1，需要需要判断如果errno是EAGAIN，则是正常的，说明缓冲区的数据处理完了。如果是其它的errno，就是真的出错了。
while(1)
{
    if((cnt = read(evs[i].data.fd, buf, BUFSIZ)) < 0)
    {
        if(errno != EAGAIN) close(evs[i].data.fd);
        break;
    }
    else if (*buf == EOF)
    {
        close(evs[i].data.fd);
        break;
    }
...
...



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

int check_epoll_err(struct epoll_event* ee)
{
    if(ee == NULL) return -1;
    if(
        ee->events & EPOLLERR ||
        ee->events & EPOLLHUP
    )
    {
        return -1;
    }
    return 1;
}


int no_block(int fd, char* errbuf)
{
    int fl = 0;
    int r  = 0;
    if((fl = fcntl(fd, F_GETFL, 0)) < 0) goto err;
    if((r  = fcntl(fd, F_SETFL, fl|O_NONBLOCK)) < 0) goto err;
    return 0;

    err:
    strcpy(errbuf, strerror(errno));
    return errno * -1;
}

int do_accept(int sock, char* errbuf)
{
    int ep = 0;
    int r = 0;
    struct epoll_event ev;
    struct epoll_event *evs;

    if(listen(sock, 1024) < 0) goto err;   
    if((ep = epoll_create1(0)) < 0) goto err;

    ev.data.fd = sock;
    ev.events = EPOLLIN|EPOLLET;
    if(epoll_ctl(ep, EPOLL_CTL_ADD, sock, &ev) < 0) goto err;

    evs = calloc(64, sizeof(ev));

    int n, i;
    struct sockaddr_in caddr;
    socklen_t addrlen;
    int cfd;
    while(1)
    {
        n = epoll_wait(ep, evs, 64, -1);
        for(i=0; i<n; i++)
        {
            if(check_epoll_err(&(evs[i])) < 0)
            {
                 close(evs[i].data.fd);
                continue;
            }
            else if(sock == evs[i].data.fd)
            {
                while(1) //loop try one non_block fd.
                {
                    if((cfd = accept(sock, (struct sockaddr*)&caddr, &addrlen)) < 0)
                    {
                        if(errno == EAGAIN || errno == EWOULDBLOCK)
                            break; // all connection accepted.
                        else
                            goto err;
                    }
                    printf("accept client: %s:%d\n", inet_ntoa(caddr.sin_addr), caddr.sin_port);

                    // make client fd non_block.
                    if((no_block(cfd, errbuf)) < 0) goto err;

                    // add client into epoll.
                    ev.data.fd = cfd;
                    ev.events = EPOLLIN|EPOLLET;
                    if(epoll_ctl(ep, EPOLL_CTL_ADD, cfd, &ev) < 0) goto err;
                    continue;
                }
                puts("accept ok");
            }
            else
            {
                // client fd ready.
                if(evs[i].events & EPOLLIN == EPOLLIN)
                {
                    int cnt;
                    char buf[BUFSIZ];
                    int finish = 0;
                    char hello[10] = "hello: ";
                    while(1)
                    {
                        if((cnt = read(evs[i].data.fd, buf, BUFSIZ)) < 0)
                        {
                            if(errno != EAGAIN) close(evs[i].data.fd);
                            break;
                        }
                        else if (*buf == EOF)
                        {
                            close(evs[i].data.fd);
                            break;
                        }
                        printf("from client: %s", buf);
                        if(write(evs[i].data.fd, hello, strlen(hello)) < 0) goto err;
                        if(write(evs[i].data.fd, buf, cnt) < 0) goto err;
                    }
                }
            }
        }
    }

    return 0;

    err:
    strcpy(errbuf, strerror(errno));
    return errno * -1;
}

int do_listen(int port, char* errbuf)
{
    int r = 0;
    int sock = -1;

    struct sockaddr_in servaddr;
    servaddr.sin_family = AF_INET;
    inet_pton(AF_INET, "0.0.0.0", &servaddr.sin_addr);
    servaddr.sin_port = htons(port);
    if((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) goto err;
    else if((r = bind(sock, (struct sockaddr*)&servaddr, sizeof(servaddr))) != 0) goto err;

    int opt = 1;
    setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
    // make client fd non_block.
    if((no_block(sock, errbuf)) < 0) goto err;
    return sock;

    err:
    strcpy(errbuf, strerror(errno));
    return errno * -1;
}



int main()
{
    int port = 1111;
    int r = 0;
    char errbuf[BUFSIZ];
    int sock = do_listen(port, errbuf);

    if(sock < 0)
    {
        puts(errbuf);
        exit(errno);
    }

    r = do_accept(sock, errbuf);
    if(r < 0)
    {
        puts(errbuf);
        exit(errno);
    }

    return 0;
}

来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/26239116/viewspace-2075385/，如需转载，请注明出处，否则将追究法律责任。

转载于:http://blog.itpub.net/26239116/viewspace-2075385/

cmbj68996
关注
Linux C 多进程下载文件demo
田航语
02-17 1861
1、使用多进程，实现多个客户端同时下载文件目录： 头文件#include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <unistd.h> #include <stdio.h> #include <stdlib.h> #include <sys/uio.h> #include <sys/socket.h> #inc
linux网络编程--多并发服务器(多路I/O--epoll)
weixin_45639955的博客
03-02 705
1操作函数 1.1创建int epoll_create(int size) 本质 创建一个红黑树（是平衡2叉树中的一个特例） 参数 size 创建的红黑树的监听节点的数目 返回值 指向新创建的红黑树的根结的文件描述符epfd 失败 - 1 errno 1.2控制int epoll_ctl(int epfd, int op, int fd, struct epoll_even...
简 易 版 的 进 程 池 模 型 学 习
smilejiasmile的博客
07-17 385
简 易  版 的 进 程 池 模  型 学 习 1、进程池流程 父进程流程 第一步： make_child 初始化子进程 循环创建子进程，并初始化父进程的子进程管理结构体数组 child， 通过 socket_pair 将 socket描述符一端放入数组 子进程流程 recv_fd 等待父进程发送任务 send_file 发送
Linux网络编程
Jiangtagong的博客
08-18 1267
本文的笔记来自于b站视频的爱编程的大丙，博客链接：https://subingwen.cn/，有做了相应的补充！
Epoll
方池安夏的博客
04-03 1709
目录Epoll - IO多路复用怎么理解创建Epoll向EPOLL对象中添加、修改或者删除感兴趣的事件收集在epoll监控的事件中已经发生的事件完整代码 Epoll - IO多路复用 怎么理解 类比快递员寄快递，传统方式是快递员挨家挨户上楼敲门现，在改为用快递柜子的方式，比如丰巢类似，现在这里有两个集合。 1.住户所有人是一个集合。 2.丰巢是一个子集，比如今天要寄快递的住户。 epoll就是管理这两个集合。 epoll_create相当于一栋楼，聘请了一个快递员，创建一栋楼 epoll_ctl往楼里搬住
epoll详解
wangbuji的博客
01-12 759
linux系统一切皆文件，设备，socket等都可以理解为是一个文件。 select,pool,epoll都能管理多个socket，但select最多管理1024个socket，poll没有1024个数限制但效率不高，目前主流方案是epoll。 epoll三个接口函数 #include <sys/epoll.h> //创建一个epoll句柄，参数size是内核保证能够正确处理的最大句柄数，多于这个最大数时内核不保证效果。当创建好epoll句柄后，它就是会占用一个fd值，在linux下
Linux-epoll机制
chenwr2018的博客
02-16 3628
主要接口 epoll_create epoll_ctl epoll_wait epoll_create 头文件 #include <sys/epoll.h> 函数原型 int epoll_create(int size); int epoll_create1(int flags); 成功返回整型fd，失败返回-1 作用 创建一个epoll的句柄，size用来告诉内核这个监听的数目一共有多大。这个参数不同于select()中的第一个参数，给出最大监听的fd+1的值。需要注意的是，当创建好ep
epoll使用详解
k916631305的博客
11-04 3487
在linux的网络编程中，很长的时间都在使用select来做事件触发。在linux新的内核中，有了一种替换它的机制，就是epoll。 相比于select，epoll最大的好处在于它不会随着监听fd数目的增长而降低效率。因为在内核中的select实现中，它是采用轮询来处理的，轮询的fd数目越多，自然耗时越多。并且，在linux/posix_types.h头文件有这样的声明： #define __FD_SETSIZE 1024 表示select最多同时监听1024个fd，当然，可以通过修改头文件再重编译内...
epoll分析
xl365t
03-15 575
一、用户态epoll用法 #include &lt;sys/epoll.h&gt; int epoll_create(int size); // 创建一个epoll的句柄，size用来告诉内核这个监听的数目一共有多大。 // 当创建好epoll句柄后，它就会占用一个fd值。在使用完epoll后，必须调用close()关闭，否则可能导致fd被耗尽。 // 返回值：非负的文件描述符(fd) ...
linux epoll多线程编程 例子
01-19
在Linux系统中，epoll是I/O多路复用技术的一种高效实现，它极大地改进了传统的轮询方式，尤其在处理大量并发连接时表现出色。本文将深入探讨如何在多线程环境中使用epoll进行程序设计，以提高系统的并行处理能力。 ...
netty-transport-classes-epoll-4.1.74.Final-API文档-中文版.zip
07-07
赠送jar包：netty-transport-classes-epoll-4.1.74.Final.jar； 赠送原API文档：netty-transport-classes-epoll-4.1.74.Final-javadoc.jar； 赠送源代码：netty-transport-classes-epoll-4.1.74.Final-sources.jar；...
epoll 使用golang实现
05-05
在IT领域，`epoll`是一种高效的I/O事件通知机制，尤其在处理大量并发连接时，它是Linux系统下的首选方案。`epoll`利用内核与用户空间的共享数据结构来减少上下文切换，提高了系统在高并发环境下的性能。本篇文章将...
epoll机制epoll_create、epoll_ctl、epoll_wait、close(在epoll的ET模式下，read和write或send和recv当返回值0且errno=EAGAIN - linking530的专栏 - 优快云博客.mht
01-03
epoll机制epoll_create、epoll_ctl、epoll_wait、close(在epoll的ET模式下，read和write或send和recv当返回值0且errno=EAGAIN - linking530的专栏 - 优快云博客.mht
netty-transport-classes-epoll-4.1.73.Final-API文档-中英对照版.zip
05-03
赠送jar包：netty-transport-classes-epoll-4.1.73.Final.jar； 赠送原API文档：netty-transport-classes-epoll-4.1.73.Final-javadoc.jar； 赠送源代码：netty-transport-classes-epoll-4.1.73.Final-sources.jar；...
【Linux网络与网络编程】14.多路转接 —— select && poll && epoll
caryon的博客
04-30 792
对Linux中多路转接的方法select、poll、epoll进行了详细的介绍，并通过代码来加深理解
C++日更八股--day2
wjm041006的博客
04-30 254
loop：事件循环：​​事件循环​​是一个持续运行的循环结构，负责监听和分发事件。1.快速排序：作为主要算法，它通过选择一个pivot元素，将序列划分为两个子序列，一个子序列元素小于枢轴，另一个大于，随后递归排序，时间复杂度达到O(nlogn).vector，这个容器为动态数组，相信学过操作系统分区分配的朋友一定知道，我如果在连续的存储空间中扩容的做法为再找一片空间，当前内容复制过去，再插入。epoll（事件通知）：当有文件描述符需要服务的时候，才会通知，且返回的为需要服务的文件描述符，避免遍历。
epoll函数
2301_80657297的博客
05-01 755
实例中监控的文件描述符上的事件发生。当有事件发生时，该函数会返回发生事件的文件描述符数量，并将这些事件的信息存储在。实例进行控制操作，比如添加、修改或删除要监控的文件描述符及其对应的事件。：表示等待指定的毫秒数，如果在这段时间内没有事件发生，则返回。成功时返回发生事件的文件描述符数量。数组的最大元素个数，即最多能存储的事件数量。：表示对应的文件描述符可写（可以写入数据）。结构体的指针，用于指定要监控的事件类型。：表示对应的文件描述符可读（有数据可读）。实例，返回一个文件描述符，后续的。
Linux 的 epoll 与 Windows 的 IOCP 详解
最新发布
2301_80355452的博客
05-03 481
简单说，就是你手里有很多任务（比如很多客户端的请求），但系统的核心（线程或者进程）资源有限，你怎么快速、同时处理这些请求？这个问题就属于“多路复用”范畴。就像你在吃饭，有很多盘菜（请求）摆在桌子上，你想用一只筷子（单个线程）快速夹起来吃掉，并且处理所有盘子里的菜。如果每个请求都用单独的线程跑，效率低，资源浪费严重。而“多路复用”技术，就是让一只或者少数几只“筷子”可以轮流“夹”住多个“盘子”，高效处理。epoll：Linux中高效的多路复用事件通知机制，支持大规模连接，节省资源。IOCP。
深入解析Epoll机制
"Epoll原理详解" Epoll是Linux操作系统中用于高效处理大量并发I/O事件的一种机制，尤其在高并发网络编程中表现出色。相比于传统的select()和poll()，Epoll具有更高的性能和更低的延迟。本文将深入探讨Epoll的工作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值