epoll（未完待续）

最新推荐文章于 2024-05-26 21:24:14 发布
最新推荐文章于 2024-05-26 21:24:14 发布
阅读量67 收藏
点赞数
文章标签： epoll 数据结构与算法 python
原文链接：https://my.oschina.net/michaelyuanyuan/blog/144645
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

2013-07-15，重构了epoll服务器模型的代码

两种不同的触发器模型：边沿触发（ET：Edge-Trigger）和水平触发（LT：Level-Trigger）

    1. 边沿触发（ET：Edge-Trigger）：当调用前条件是unready，并且调用过程中条件变成ready，才给予调用者通知。

    假设调用代码是ret = check(condition);，如果调用时的condition是ready的，那么即使接下来condition还是ready，check函数返回给ret还是无效通知或者不返回（阻塞式）。当且仅当condition的值是unready时，然后在调用的过程中，condition变成了ready，那么此时check函数会返回一个有效通知给ret。

    2. 水平触发（LT：Level-Trigger）：当调用时条件是ready，就给予调用者通知。

    假设调用代码是ret = check(condition);，只要调用时，condition是ready的，check函数就会返回一个有效通知给ret，否则返回无效通知或者不返回（阻塞式）。

    首先，什么叫把condition的条件变成ready或者unready。假设有个这样的场景：我们监听一个网络套接字sockfd上是否有数据可读，假定有数据可读就是ready状态，没数据可读就是unready状态。

    容易出错的往往是ET模型。假设sockfd上一开始是没有数据可读（unready），然后我调用ret = check(sockfd);，以阻塞式为例吧，那么此时线程会一直阻塞在check里面。某一时刻，远方有人往该sockfd上发来数据，那么该sockfd的状态就由unready变成了ready，显而易见，check应该返回一个有效通知，此时该线程收到通知，然后去读。注意看，接下来有两种情况：1）线程开始读取sockfd的数据，直到全部读取完毕，然后又调用check(sockfd)；2）线程开始读取sockfd的数据，没有全部读取完毕，然后又调用check(sockfd)。首先说结果，1）是正确的，2）是错误的。然后说为什么。相信已经能够理解，把ready转换成unready的操作就是全部读完sockfd的数据，把unready转换成ready的操作就是远方有人发数据到该sockfd来了。2）错就错在，没有把sockfd的数据读干净，以至于没有把状态变成unready，那么即使后面又来了新数据，check(sockfd);还是会一直阻塞下去。所以使用ET模型的时候，一定要注意，每次收到有效通知，然后读取数据的时候，务必每次读干净（读到出错为止）。当再次调用check(sockfd);的时候才能正确返回。

    那么LT模型却不会出现ET模型中的2）情况。为什么呢？设想一下，即使你没有读取完数据，又去调用check(sockfd);，因为LT的特性，只要是ready状态就发有效通知，所以，你懂的！

epoll()是什么，它诞生于什么时候，它在哪诞生，它诞生的意义是什么？

    epoll()类似于poll()和select()，也是一种能是的I/O多路复用的机制，它诞生于Linux内核2.6版本，它在Linux可用，它是一种它综合后面二者的优势，剔除后面二者的弊端，它诞生的意义完全就是来取代后面二者的。

epoll()比起select()和poll()来说，好在哪？

    1. select()：一次性可以同时监控FD_SETSIZE个fds，FD_SETSIZE在编译阶段才被确定的，但是很明显，FD_SETSIZE是固定的、有限的。

    2. poll()：一次性可监控的fds个数是不固定的，看起来这是个好处，比select()灵活且更多，但是问题来了，每一次调用，我们需要对传进去的所有的fds进行一次线性扫描，将花掉O(n)的时间，这个消耗很大。

    3. epoll()：顾名思义——Enhanced POLL，poll()的加强版。epoll()对于一次性监控的文件描述符个数没有限制（poll()的长处），不需要做线性扫描（避免poll()的短处）。可想而知，epoll()的性能比二者更高。

为什么epoll()有两种工作模式，LT和ET，哪种更高端、大气？

    ET比LT更高端、更装逼。当然装逼有风险，也意味着ET更难用，用不好更容易出错。

epoll()怎么用？

    epoll机制包含以下几个操作方法和数据结构：

    操作方法：

    1. int epoll_create(int size);

    返回值是一个epoll描述符，size是你想创建一个多大的监听队伍！

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

    往epfd队列里注册一个op方式的fd，要求监控fd的event系列的事件

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

    等待epfd队列中的所有注册的fd发生事件，一般timeout用-1，表示永久阻塞。

    PS：本人最近在学习iOS开发，事实上，当一个函数的参数上升到4、5个之后，要记住每个参数的意义就显得麻烦了，除非你天天用。那么Objective-C的优势就体现出来了，它会标记出每个参数的意义，相当注释了。

   数据结构：

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 ：表示对应的文件描述符可以读（包括对端SOCKET正常关闭）；

EPOLLOUT：表示对应的文件描述符可以写；

EPOLLPRI：表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）；

EPOLLERR：表示对应的文件描述符发生错误；

EPOLLHUP：表示对应的文件描述符被挂断；

EPOLLET： 将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)来说的。

EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里。

从代码出发吧！！！已在Fedora-19-64bit通过编译，运行测试OK 

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

#define FAIL -1
#define SUCC  0
#define TRUE  1
#define FALSE -1

#define SERVER_PORT 7892
#define SERVER_IP_ADDRESS "192.168.1.100"

//epoll
#define MAX_EPOLL_QUEUE 1024

//listen
#define MAX_LISTEN_QUEUE 10

#define ylog(fmt, ...)\
    do {\
            fprintf(stdout, "ylog:[%s]:[%d]:"fmt, __FUNCTION__, __LINE__ , ##__VA_ARGS__);\
    } while(0)


struct sockaddr_in serverSockaddr_in;

int setnonblocking(int sockfd)
{
    int opts;
    opts=fcntl(sockfd,F_GETFL); // 把sock的属性查询出来，存到opts中

    if(opts<0)
    {
        ylog("fcntl(sockfd,GETFL)\n");
        return FALSE;
    }

    opts = opts | O_NONBLOCK; // 把opts中的某一位O_NONBLOCK置为生效

    if(fcntl(sockfd,F_SETFL,opts)<0) // 再设回去，搞定
    {
        ylog("fcntl(sockfd,SETFL,opts)\n");
        return FALSE;
    }
    return SUCC;
}

int network_socket(int __domain, int __type, int __protocol)
{
    int fd = -1;
    fd = socket(__domain, __type, __protocol);
    if (fd < 0)
    {
        ylog("socket error: [%s]\n", strerror(errno));
        return FAIL;
    }
    else
    {
        return fd;
    }
}

int network_sockaddr(struct sockaddr_in *__server, int __protocol_family, int __port, char *__ip_address, int __ip_address_len)
{
    memset(__server, 0x00, sizeof(struct sockaddr_in));
    __server->sin_family = __protocol_family;
    inet_aton(__ip_address,&(__server->sin_addr));
    __server->sin_port = htons(__port);
    return SUCC;
}

int network_bind_init(int _fd, struct sockaddr* _sockaddr, size_t _size)
{
    int ret = FAIL;
    ret = bind(_fd, _sockaddr, _size);
    if (ret != 0)
    {
        ylog("bind error: %s\n", strerror(errno));
        return FAIL;
    }
    else
    {
        return SUCC;
    }
}

int network_init(int *_listenFd)
{
    int listenFd = FAIL, ret = FAIL;
    if (FAIL == (listenFd = network_socket(AF_INET, SOCK_STREAM, 0)))
    {
        ylog("network_socket_init error\n");
        return FAIL;
    }
    //ylog("finished network_socket\n");

    if (SUCC != (ret = network_sockaddr(&serverSockaddr_in, PF_INET, SERVER_PORT, SERVER_IP_ADDRESS, sizeof(SERVER_IP_ADDRESS))))
    {
        ylog("network_sockaddr_init error, ret = [%d]\n", ret);
        return ret;
    }
    //ylog("finished network_sockaddr\n");

    if (SUCC != (ret = network_bind_init(listenFd, (struct sockaddr*)&serverSockaddr_in, sizeof(serverSockaddr_in))))
    {
        ylog("network_bind_init error, ret = [%d]\n", ret);
        return ret;
    }
    //ylog("finished network_bind_init\n");

    *_listenFd = listenFd;
    return SUCC;
}

int case_new_client_event(int _fd, int _handle, struct epoll_event *_event)
{
    int client_fd;
    struct sockaddr_in client;
    socklen_t client_len = sizeof(client);
    struct epoll_event ev = {0};
    ylog("new client event comes\n");
    client_fd = accept(_fd, (struct sockaddr *)&client, &client_len); // 先accept才能知道客户端的信息
    if (client_fd < 0)
    {
        ylog("accept faild: %s\n", strerror(errno));
        return FALSE;
    }
    ylog("new client is comming from [%s]\n", inet_ntoa(client.sin_addr));
    setnonblocking(client_fd);
    ev.events = EPOLLIN | EPOLLET;
    ev.data.fd = client_fd;
    epoll_ctl(_handle, EPOLL_CTL_ADD, client_fd, &ev);

    return SUCC;
}

int case_read_event(int _fd, int _handle, struct epoll_event *_event)
{
    return SUCC;
}

int case_write_event(int _fd, int _handle, struct epoll_event *_event)
{
    return SUCC;
}

int my_switch(int _fd, int _handle, struct epoll_event *_event)
{
    if (_event->data.fd == _fd)
    {
        case_new_client_event(_fd, _handle, _event);
    }
    else if (_event->events & EPOLLIN)
    {
        case_read_event(_fd, _handle, _event);
    }
    else if (_event->events & EPOLLOUT)
    {
        case_write_event(_fd, _handle, _event);
    }
    else
    {
        ylog("nothing to be done\n");
    }

    return SUCC;
}

int loop(int _fd, int _handle)
{
    struct epoll_event ev_queue[MAX_EPOLL_QUEUE];
    int total = -1, i = -1;
    for(;;)
    {
        total = epoll_wait(_handle, ev_queue, MAX_EPOLL_QUEUE, -1);

        for(i = 0; i < total; i++)
        {
            if (FAIL == my_switch(_fd, _handle, &(ev_queue[i])))
            {
                return FAIL;
            }
        }

    }
    return SUCC; // program would never reach this line
}

int main()
{
    int listenFd = -1, ret = FAIL;
    int epoll_handle = -1;
    struct epoll_event ev;
    ylog("start!\n");

    ret = network_init(&listenFd); // do all the trivial jobs for one only propose that get a listenFd
    if (ret != SUCC)
    {
        ylog("network_init failed: ret = [%d]\n", ret);
        return ret;
    }
    // codes below are very important

    // have got the listenFd, set it to non-blocking property
    setnonblocking(listenFd);

    // create a epoll handle
    epoll_handle = epoll_create(MAX_EPOLL_QUEUE); // MAX_EPOLL_QUEUE is 1024

    // add the listenFd to the queue through the handle, with the events you are interested
    ev.data.fd=listenFd; //设置与要处理的事件相关的文件描述符
    ev.events=EPOLLIN | EPOLLET; //设置要处理的事件类型和使用的触发器的机制
    epoll_ctl(epoll_handle, EPOLL_CTL_ADD, listenFd, &ev); //把listenfd注册到epfd队列中，监听EPOLLIN事件，使用EPOLLET机制的触发器

    // start to listen the client's sync package
    ret = listen(listenFd, MAX_LISTEN_QUEUE);
    if (0 != ret)
    {
        ylog("listen failed: ret = [%d]\n", ret);
        return ret;
    }

    // loop() function is a typical model of using epoll mechanism
    loop(listenFd, epoll_handle);

    return 0;
}









转载于:https://my.oschina.net/michaelyuanyuan/blog/144645

weixin_33889245
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
开发岗学习路线（未完待续）
qq_42651799的博客
03-22 582
计网 1、TCP三次握手，四次挥手，有什么用？ ２、HTTP８种请求方法：GET、HEAD、POST、PUT、DELETE、CONNECT、OPTIONS、TRACE GET和POST的区别？ ＊　GET被浏览器强制支持 ＊　由于URL长度有限制，GET不能代替POST发送大量的数据 ＊　GET请求发送数据更小 ＊　GET是不安全的，POST相对于GET是安全的 ＊　GET是幂等的 ＊　POST不能被缓存 ３、HTTP1.0，1.1，2.0区别 1.0默认短连接，1.1及以后默认长连接 1.1支持只发送h
Android消息机制（未完待续~~）
qq_33613491的博客
05-20 120
一、消息机制介绍 首先，要了解消息机制中的四个概念； A Handler：具体处理逻辑的地方 B MessageQueue：具有时间优先级的消息队列 C Looper：轮询消息队列，看是否有新的消息到来 D ThreadLocal：当前线程存储的数据仅能从当前线程取出 然后，理清这几者之间的关系： 二、Looper在主线程中死循环为什么没有导致界面的卡死？ 三、IdleHandler介绍？ 四、...
linux 2.6内核epoll用法举例
郭耀今 -- 蓝天白云
12-22 930
 linux 2.6内核epoll用法举例说明(续)--给echo服务器增加读线程池上篇文章使用linux内核2.6 提供的epoll机制实现了一个反应式echo服务器，使用反应式服务器的最大好处就是可以按cpu的数量来配置线程池内线程的线程数而不是根据客户端的并发量配置线程池。我是第一次使用pthread库来写线程池，使用的是工作队列方式的线程池。我感觉作队列方式的线程池可以当成一种设计模式来用
nginx记录！未完待续
smxr
03-31 130
NGINX基础学习 相关基本Linux指令 # 开启 service firewalld start # 重启 service firewalld restart # 关闭 service firewalld stop # 查看防火墙规则 firewall-cmd --list-all # 查询端口是否开放 firewall-cmd --query-port=8080/tcp # 开放80端口 firewall-cmd --permanent --add-port=80/tcp # 移除端口 firewal
Nginx配置——未完待续
qq_16399457的博客
01-12 108
nginx的配置项可以大致分如下几个部分 1. 全局配置：包括 user user [group] 允许运行nginx的用户|组 worker process数 这是nginx实现并发处理的关键所在。配置格式如下： worker process number |auto; number 表示启动的worker进程数 auto nginx进程自动检测 查看运行中的worker process进...
2022互联网面经(未完待续)
weixin_42335835的博客
03-08 1020
字节一面（2022.2.16）（55min） 深信服一面（2022.2.19）(40min) shopee深圳虾皮一面（2022.2.19）(80min) 腾讯互娱一面 （2022.02.22）（50min） shopee深圳虾皮一面（2022.2.23）(70min) 深信服一面（2022.2.24）(46min) 富途一面（2022.2.24）(70min)
2024大数据Java面试总结（未完待续）
2401_84150394的博客
04-29 460
启动SpringFactories的实例，都是利用AutoConfiguration的实例，也就是 Springboot自动配置和零xml配置的核心，这里模仿了java的SPI机制，很多框架里面都有所使用。启动过程最重要的是SpringFactoriesLoader进行自动配置的过程（此过程类似于java的spi机制，可以进行适度的发散）redis应用，不仅仅是做一个kv缓存去用吧（介绍的时候千万不要拘泥于项目，一定要把redis的功能全部阐述出来）服务治理中心，实现某节点的禁用（dubbo-admin）
Linux 系统编程总结 (未完待续)
HongDaYu的搬砖之路
12-06 864
前言 我记得去年说过要讲一些干货分享给大家，Linux 系统编程是linux 驱动开发入门的条件 有人说为什么? mmap select read write open ioctl socket poll epoll 这几个系统API 大家如果熟悉的话就非常熟悉了,其实就使用来讲就很基础了,本质上就是和内核进行交互 如果只是单纯的做linux 系统应用层的开发,建议学习下 Nginx 的源码,这里面的设计模式很值得学习,我买了本Nginx 讲解源码的书 但是没看过,在几天前,我也下定了一个决心定了一个研究
EPOLL
chylovecsd的博客
05-25 62
epoll经典使用方法 Epoll的使用详解 Socket描述符选项[SOL_SOCKET] socket —— Linux套接字接口 setsockopt用法详解 Android P Uevent机制分析 socket编程accept函数返回值的理解 socket和accept返回的套接字(fd)有什么区别 常见开源服务器模型学习 未完待续 《Linux设备节点创建》内核kobject上报uevent过滤规则 accept与epoll惊群 网络编程s.
epoll与reactor
05-14
epoll与reactor
c语言 epoll
03-17
libevent 截取框架代码，修改简易代码 epoll 事件循环
epoll-sever.zip
05-10
epoll-sever，基于C语言编写的高并发Epoll服务器，epoll-sever，基于C语言编写的高并发Epoll服务器，epoll-sever，基于C语言编写的高并发Epoll服务器epoll-sever，基于C语言编写的高并发Epoll服务器
epoll源码剖析
02-21
本文详细介绍了epoll的原理和Linux内核中如何实现epoll_create、epoll_ctl、epoll_wait.
linux epoll多线程编程 例子
01-19
linux epoll多线程编程 例子
【无标题】
Wuyp21441X的博客
05-23 759
（在32位的机器上，大小就是3232，同理64位机器上FD_SETSIZE为3264），当然我们可以对进行修改，poll：poll本质上和select没有区别，但是它没有最大连接数的限制，原因是它是基于链表来存储的。使用epoll没有前面两者的线性下降的性能问题，但是所有socket都很活跃的情况下，可能会有性能问题。链表的存储方式和顺序表截然相反，什么时候存储，什么时候才申请存储空间，数据之间的物理地址不连续。3、共享资源的方式不同：进程之间是不能共享资源的，线程之间可以共享资源（内存、打开的文件）
【poll函数ppoll函数与epoll函数的区别】
最新发布
“Struggle”的博客
05-26 370
epoll 是一个更现代、更高效的IO多路复用机制，特别适合于需要处理大量并发连接的应用程序，如网络服务器和负载均衡器。而 poll 和 ppoll 则提供了基本的多路复用功能，适用于对性能要求不是特别高的场景，或者需要处理信号的场景。
【Muduo】三大核心之Poller、EPollPoller
qq_20756957的博客
05-23 1013
EPollPoller根据epoll_wait返回的文件描述符集合和事件类型，通过在epoll_event的data.ptr字段预先设置Channel对象的地址，从而能够找到对应的Channel对象，并调用其上的回调函数来处理事件。可以添加新的文件描述符、修改已注册的文件描述符的事件类型或删除已注册的文件描述符。：EPollPoller利用了epoll机制的高效性，能够同时监听大量的文件描述符，并且在有事件发生时只返回有事件发生的文件描述符集合，避免了轮询所有文件描述符的开销。
C++ socket epoll IO多路复用
笔记
05-25 394
IO多路复用通常用于处理单进程高并发，在Linux中，一切皆文件，一个socket连接会对应一个文件描述符，在监听多个文件描述符的状态应用中epoll相对于select和poll效率更高。epoll本质是系统在内核维护了一颗红黑树，监听的文件描述符会作为新的节点插入红黑树，epoll会等待有状态变化的节点记录在链表里，然后拷贝到用户所给的数组里面返回出来。简单测试服务端，打开Linux终端，用一下命令连接服务器后即可传输数据。以下是一个独立的服务端代码，可以补充业务代码进行具体使用。
select epoll
05-15
select 和 epoll 都是 Linux 下常用的 I/O 多路复用机制，用于同时监听多个文件描述符的 I/O 事件，并在事件到来时进行相应的处理。 select 是最早的多路复用技术，它使用 fd_set 类型的文件描述符集合来实现，支持...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值