linux poll与epoll模型简介

最新推荐文章于 2022-11-19 19:36:14 发布
最新推荐文章于 2022-11-19 19:36:14 发布
阅读量688 收藏 1
点赞数
分类专栏： c/c++ 文章标签： epoll linux 网络服务器 高性能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lbcab/article/details/51766465
版权

Linux I/O复用
高性能的网络服务器需要同时并发处理大量的客户端，而采用以前的那种对每个连接使用一个分开的线程或进程方法效率不高，因为处理大量客户端的时候，资源的使用及进程上下文的切换将会影响服务器的性能。一个可替代的方法是在一个单一的线程中使用非阻塞的I/O（non-blocking I/O）。

1.poll 函数原型：

#include<poll.h>
int poll(struct pollfd *fds, nfds_t nfds, int timeout);

struct pollfd{
    int fd;             /*file descriptor*/
    short events;   /*requested events*/
    short revents;   /*returned events*/
};

poll 使用基本流程：
listenfd POLLIN事件到来 —〉connfd = accpt(…);
关注connfd的POLLIN事件

遍历已连接字套接字集
connfd POLLIN事件到来
read(connfd, ….);
write(connfd, ….);

遍历已连接字套接字集
connfd POLLIN事件到来
read(connfd, ….);
ret = write(connfd, buf, 10000);
if(ret < 10000)
{
将未发完的数据添加应用层缓冲区OutBuffer
关注connfd的POLLOUT事件
}
connfd POLLOUT事件到来
取出应用层缓冲区中的数据发送 write(connfd, ….);
如果应用层缓冲区中的数据发送完毕，取消关注POLLOUT事件

2.accept 返回EMFILE（太多的文件，打开的文件描述符超出上限）的处理
1)调高进程文件描述符数目(治标不治本)
2)死等
3)退出程序（不能满足服务器7*24小时不间断工作）
4)关闭监听套接字。那什么时候重新打开?(不现实)
5)如果是epoll模型，可以改用edge trigger(边沿触发).问题是如果漏掉一次accept，程序再也不会收到新连接。
6)准备一个空闲的文件文件描述符。遇到这种情况，先关闭这个空闲文件，获得一个文件描述符名额；再accpet拿到socket连接的文件描述符；随后立刻close，这样就优雅地断开了与客户端的连接；最后重新打开空闲文件，把‘坑’填上，以备再次出现这种情况时使用。

服务器参考程序：

#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
#include <sys/wait.h>
#include <poll.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <vector>
#include <iostream>
#define ERR_EXIT(m) \
        do \
        { \
                perror(m); \
                exit(EXIT_FAILURE); \
        } while(0)
typedef std::vector<struct pollfd> PollFdList;
int main(void)
{
    signal(SIGPIPE, SIG_IGN);
    signal(SIGCHLD, SIG_IGN);
    int idlefd = open("/dev/null", O_RDONLY | O_CLOEXEC);
    int listenfd;
    //if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
    if ((listenfd = socket(PF_INET, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, IPPROTO_TCP)) < 0)
        ERR_EXIT("socket");
    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(5188);
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    int on = 1;
    if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
        ERR_EXIT("setsockopt");
    if (bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
        ERR_EXIT("bind");
    if (listen(listenfd, SOMAXCONN) < 0)
        ERR_EXIT("listen");
    struct pollfd pfd;
    pfd.fd = listenfd;
    pfd.events = POLLIN;
    PollFdList pollfds;
    pollfds.push_back(pfd);
    int nready;
    struct sockaddr_in peeraddr;
    socklen_t peerlen;
    int connfd;
    while (1)
    {
        nready = poll(&*pollfds.begin(), pollfds.size(), -1);
        if (nready == -1)
        {
            if (errno == EINTR)
                continue;

            ERR_EXIT("poll");
        }
        if (nready == 0)    // nothing happended
            continue;

        if (pollfds[0].revents & POLLIN)
        {
            peerlen = sizeof(peeraddr);
            connfd = accept4(listenfd, (struct sockaddr*)&peeraddr,
                        &peerlen, SOCK_NONBLOCK | SOCK_CLOEXEC);
/*          if (connfd == -1)
                ERR_EXIT("accept4");
*/
            if (connfd == -1)
            {
                if (errno == EMFILE)
                {
                    close(idlefd);
                    idlefd = accept(listenfd, NULL, NULL);
                    close(idlefd);
                    idlefd = open("/dev/null", O_RDONLY | O_CLOEXEC);
                    continue;
                }
                else
                    ERR_EXIT("accept4");
            }
            pfd.fd = connfd;
            pfd.events = POLLIN;
            pfd.revents = 0;
            pollfds.push_back(pfd);
            --nready;
            // 连接成功
            std::cout<<"ip="<<inet_ntoa(peeraddr.sin_addr)<<
                " port="<<ntohs(peeraddr.sin_port)<<std::endl;
            if (nready == 0)
                continue;
        }
        //std::cout<<pollfds.size()<<std::endl;
        //std::cout<<nready<<std::endl;
        for (PollFdList::iterator it=pollfds.begin()+1;
            it != pollfds.end() && nready >0; ++it)
        {
                if (it->revents & POLLIN)
                {
                    --nready;
                    connfd = it->fd;
                    char buf[1024] = {0};
                    int ret = read(connfd, buf, 1024);
                    if (ret == -1)
                        ERR_EXIT("read");
                    if (ret == 0)
                    {
                        std::cout<<"client close"<<std::endl;
                        it = pollfds.erase(it);
                        --it;
                        close(connfd);
                        continue;
                    }
                    std::cout<<buf;
                    write(connfd, buf, strlen(buf));

                }
        }
    }
    return 0;
}

2.signal(SIGPIPE, SIG_IGN)
如果客户端关闭套接字close
而服务器端调用一次write，服务器会接收一个RST segment(TCP传输层)
如果服务器再次调用write，这个时候会产生SIGPIPE信号。如果我们不处理这个信号，默认处理方式就是关闭服务器。
因为大并发服务器需要 7 * 24 小时不间断，所以我们需要对这个信号处理。

3.TIME_WAIT 状态对大并发服务器的影响
应尽可能在服务器端避免出现TIME_WAIT状态
如果服务器端 主动断开连接(先与client 调用close)，服务器端就会进入TIME_WAIT

协议设计上，应该让客户端主动断开连接，这样把TIME_WAIT状态分散到大量的客户端
如果客户端不活跃了，一些客户端不断开连接，这样子就会占用服务器端的连接资源，服务器也要有个机制来踢掉不活跃的连接，进行close。

epoll LT
它提供了一种类似select或poll函数的机制：

  1. Select(2)只能够同时管理FD_SETSIZE数目的文件描述符

  2. poll(2)没有固定的描述符上限这一限制，但是每次必须遍历所有的描述符来检查就绪的描述符，这个过程的时间复杂度为O(N)。

    每次调用poll函数，都需要把监听套接字与已连接套接字所感兴趣的事件数组，copy到内核，效率比较低。

epoll/poll/select 对比：
这里写图片描述

一个进程中所能打开最多的连接数：

select： 32位： 32 * 32 64位：32 * 64

poll： poll本质与select没什么区别，但是他没有最大连接数的限制，原因是他是基于链表存储的

epoll：虽然连接数有限制，但是很大，1 G内存的机器上可以打开10万左右的连接，2 G是20万左右。

epoll没有select这样对文件描述符上限的限制，也不会像poll那样进行线性的遍历，不需要进行数据copy。因此epoll处理大并发连接有着更高的性能

epoll 处理流程图：

这里写图片描述

epoll的示例程序：

/****
*头文件略
****/
typedef std::vector<struct epoll_event> EventList;
#define ERR_EXIT(m) \
        do \
        { \
                perror(m); \
                exit(EXIT_FAILURE); \
        } while(0)
int main(void)
{
    signal(SIGPIPE, SIG_IGN);
    signal(SIGCHLD, SIG_IGN);
    int idlefd = open("/dev/null", O_RDONLY | O_CLOEXEC);
    int listenfd;
    //if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
    if ((listenfd = socket(PF_INET, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, IPPROTO_TCP)) < 0)
        ERR_EXIT("socket");
    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(5188);
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    int on = 1;
    if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
        ERR_EXIT("setsockopt");
    if (bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
        ERR_EXIT("bind");
    if (listen(listenfd, SOMAXCONN) < 0)
        ERR_EXIT("listen");
    std::vector<int> clients;
    int epollfd;
    epollfd = epoll_create1(EPOLL_CLOEXEC);   //返回一个文件描述符，也就是说epoll是以特殊文件方式体现给用户
    struct epoll_event event;
    event.data.fd = listenfd;
    event.events = EPOLLIN/* | EPOLLET*/;
    epoll_ctl(epollfd, EPOLL_CTL_ADD, listenfd, &event); //增加或删除被epoll监听的文件描述符

    EventList events(16);
    struct sockaddr_in peeraddr;
    socklen_t peerlen;
    int connfd;
    int nready;
    while (1)
    {
        //等待发生在监听描述符上的事件，保存在events中，它会一直阻塞直到事件发生
        nready = epoll_wait(epollfd, &*events.begin(), static_cast<int>(events.size()), -1);
        if (nready == -1)
        {
            if (errno == EINTR)
                continue;

            ERR_EXIT("epoll_wait");
        }
        if (nready == 0)    // nothing happended
            continue;
        if ((size_t)nready == events.size())
            events.resize(events.size()*2);
        for (int i = 0; i < nready; ++i)
        {
            if (events[i].data.fd == listenfd)
            {
                peerlen = sizeof(peeraddr);
                connfd = ::accept4(listenfd, (struct sockaddr*)&peeraddr,
                        &peerlen, SOCK_NONBLOCK | SOCK_CLOEXEC);
                if (connfd == -1)
                {
                    if (errno == EMFILE)
                    {
                        close(idlefd);
                        idlefd = accept(listenfd, NULL, NULL);
                        close(idlefd);
                        idlefd = open("/dev/null", O_RDONLY | O_CLOEXEC);
                        continue;
                    }
                    else
                        ERR_EXIT("accept4");
                }
                std::cout<<"ip="<<inet_ntoa(peeraddr.sin_addr)<<
                    " port="<<ntohs(peeraddr.sin_port)<<std::endl;
                clients.push_back(connfd);

                event.data.fd = connfd;
                event.events = EPOLLIN/* | EPOLLET*/;
                epoll_ctl(epollfd, EPOLL_CTL_ADD, connfd, &event);
            }
            else if (events[i].events & EPOLLIN)
            {
                connfd = events[i].data.fd;
                if (connfd < 0)
                    continue;
                char buf[1024] = {0};
                int ret = read(connfd, buf, 1024);
                if (ret == -1)
                    ERR_EXIT("read");
                if (ret == 0)
                {
                    std::cout<<"client close"<<std::endl;
                    close(connfd);
                    event = events[i];
                    epoll_ctl(epollfd, EPOLL_CTL_DEL, connfd, &event);
                    clients.erase(std::remove(clients.begin(), clients.end(), connfd), clients.end());
                    continue;
                }
                std::cout<<buf;
                write(connfd, buf, strlen(buf));
            }
        }
    }
    return 0;
}

Epoll的两种模式：

  1. 水平触发（LT）：使用此种模式，当数据可读的时候，epoll_wait()将会一直返回就绪事件。如果你没有处理完全部数据，并且再次在该epoll实例上调用epoll_wait()才监听描述符的时候，它将会再次返回就绪事件，因为有数据可读。ET只支持非阻塞socket。

  2. 边缘触发（ET）：使用此种模式，只能获取一次就绪通知，如果没有处理完全部数据，并且再次调用epoll_wait()的时候，它将会阻塞，因为就绪事件已经释放出来了。

ET的效能更高，但是对程序员的要求也更高。在ET模式下，我们必须一次干净而彻底地处理完所有事件。LT两种模式的socket都支持。

传递给epoll_ctl(2)的Epoll事件结构体如下所示：

typedefunionepoll_data
{
void*ptr;
intfd;
  __uint32_t   u32;
  __uint64_t   u64;
}epoll_data_t;

structepoll_event
{
  __uint32_t   events;/* Epoll events */
epoll_data_t data;/* User data variable */
};
lbcab
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux网络编程6——poll和epoll
HuanBianCheng27的博客
08-05 2146
select 出来的比较早，其缺点是监听散乱的文件描述符效率会低一点。所以使用 poll，但是 poll 效率没改进多少，所以又改进为 epoll。
Linux服务器5 --- POLL模型优缺点及服务端代码
scarificed的博客
12-21 653
POLL模型大体实现流程上与SELECT模型无异 1、POLL模型的利弊 优点: 1）单进程让服务端拥有基本的一对多响应能力。 2）实现较为简单（模型比较轻量） 3）POLL模型突破了1024的监听限制 ， POLL没有使用fd_set , 而是允许用户自定义长度监听集合数组。( 一定要考虑轮询 问题 ，轮询问题依然存在) 4）POLL将传入监听事件与传出就绪事件进行了分离，用户使用方便。 5）与传统的SELECT设置监听方式不同，SELECT采用批处理方式进行监听设置，但是POLL允许对集合中不同的SOC
linux poll和epoll
逐梦如风-毕康
12-12 659
linux pool和epool简介函数简介poll的机制与select类似，与select在本质上没有多大差别，管理多个描述符也是进行轮询，根据描述符的状态进行处理，但是poll没有最大文件描述符数量的限制。poll和select同样存在一个缺点就是，包含大量文件描述符的数组被整体复制于用户态和内核的地址空间之间，而不论这些文件描述符是否就绪，它的开销随着文件描述符数量的增加而线性增大。poll函
小结下select模型，poll模型和epoll模型
两眼一睁 神志不清
10-29 860
关于selece，poll和epoll模型的总结 首先select，poll，epoll都是IO多路复用的机制，先是监听多个文件的描述符fd，一旦某个fd就绪后，就可以进行相应的读写操作。select，poll，epoll从本质上讲都是同步I/O，都需要在读写时间就绪之后自己负责读写，这个过程时阻塞的。 上图就是多路复用模型，同其他io不同的是，IO多路复用一次可以等待多个文件描述符，大...
poll&epll 模型
u011550549的博客
11-14 326
POLL网络编程模型 PIPE信号的产生与处理，如何减少time_wait。 1.首先是创建socket，设置ip端口。（socket_nonbock,socket_closexec）每个socket都有自己的输入缓冲区和输出缓冲区。 2.再是设置端口复用，绑定端口，监听端口。 3.定义poll event结构和events数组，将监听的事件的描述符加到poll event中，并且监听po...
linux内核select/poll，epoll实现与区别
09-01
Linux内核中的`select`、`poll`和`epoll`是用于实现多路复用I/O的关键函数，它们允许程序在一个线程中同时处理多个文件描述符的读写操作，提高了系统的并发处理能力。这些函数在不同场景下各有优劣，理解它们的实现...
Linux网络通信epoll模型
07-24
epoll模型作为Linux提供的一种I/O多路复用技术，正是为了解决这一问题而设计的。本文将深入探讨epoll的工作原理、优势以及如何在实际编程中运用。 epoll，全称Event Poll，它是基于文件描述符（file descriptor）的...
linux下Epoll模型实例代码
10-16
Epoll模型相比传统的select、poll等I/O多路复用模型，具有更好的性能和可扩展性。这个"linux下Epoll模型实例代码"是一个展示如何在Linux环境下使用Epoll进行I/O事件监控的程序示例。 Epoll的核心概念包括以下几个...
Linux IO模型/epoll
04-24
总结来说，Linux的epoll模型是为了解决高并发I/O问题而设计的，通过线程池配合epoll，可以在多核CPU环境下有效地管理网络连接，优化系统资源的使用，提升服务器性能。在选择模型时，需要根据具体应用场景和需求来...
select poll epoll 代码实例
05-14
select poll epoll 代码实例
Linux——I/O复用（2）—— poll和epoll
qq_44824574的博客
02-15 1227
poll原型 poll系统调用和select类似，也是在指定时间内轮询一定数量的文件描述符，以 测试其是否有就绪者。 int poll(struct pollfd *fds, int nfds, int timeout); fds: struct pollfd类型的数组， 用来传递用户关注的文件描述符以及事件类型 struct pollfd { int fd; // 文件描述符 short events; // 关注的事件类型 如果关注多种事件类型，可以使用按位或‘|’将这些事件合到一起
Linux-高级IO之poll、epoll
weixin_45599288的博客
04-01 4625
poll基本知识 poll的优缺点 epoll epoll工作原理 epoll优点 epoll工作方式 简单的epoll LT服务器
TCP/IP，Linux多路IO模型poll，select升级版的poll模型，代码示例
ganfanren00001的博客
05-03 596
TCP/IP，Linux多路IO模型poll与代码示例 O、select本身使用上有些许不方便的地方，比如需要将所有描述符与select得到的fd_set遍历比较，比较麻烦，poll模型是select模型的升级版，使用起来更加方便一些。 一、poll函数以及参数 函数声明： #include <poll.h> int poll(struct pollfd *fds, nfds_t nfds, int timeout); 结构体声明： struct pollfd {
网络编程（3）——poll/epoll模型
weixin_42034081的博客
06-15 310
pool/epollpoll了解poll函数开发流程epoll函数说明epoll开发流程触发模式思考反应堆 poll 了解poll函数 介于select和epoll之间，用得少，只是简单了解 int poll(struct pllfd* fds, nfds_t nfds,int timeout) 函数说明：跟select相似，监控多路IO但是不能跨平台，委托内核监控可读可写，以及监控异常事件 参数选择: fds:传入传出参数，实际上是一个结构体数组 { i
网络编程-多路转接之poll与epoll模型
mxrrr_sunshine的博客
06-08 360
首先，还是需要理解io过程：io过程总体来看分两步，第一步就是等，第二步才是数据搬迁。而如果要想提高io的性能与效率，就要减少等的比重。 可以假想一个场景： 你去钓鱼，但是你只有一个鱼竿。你的同伴也和你一起去钓鱼，但是他带了100个鱼竿。假设每条鱼上钩的概率都是一样的，那么你和他相同的时间内，你在死盯着一个鱼竿，而他只需要来回巡视所有的鱼竿，一旦有鱼上钩，拿上来即可。很明显，它的这种方...
select、poll和epoll的区别和 IO多路复用模型讲解
qq_34802511的博客
08-09 4509
select、poll和epoll的区别和 IO多路复用模型讲解 IT生涯 2018-07-12 22:28:27 select、poll和epoll的区别 在linux没有实现epoll事件驱动机制之前，我们一般选择用select或者poll等IO多路复用的方法来实现并发服务程序。在大数据、高并发、集群等一些名词唱的火热之年代，select和poll的用武之地越来越有限了，风头已经被epo...
朴素、Select、Poll和Epoll网络编程模型实现和分析——模型比较
方亮的专栏
06-15 3024
经过之前四篇博文的介绍，可以大致清楚各种模型的编程步骤。现在我们来回顾下各种模型（转载请指明出于breaksoftware的csdn博客）模型编程步骤对比 《朴素、Select、Poll和Epoll网络编程模型实现和分析——朴素模型》中介绍的是最基本的网络编程模型，我们使用单线程去实现，它的步骤很简单 如同这幅流程图，它简单到非常单薄。这个模型暴露出来...
Linux网络编程4--poll和epoll
qq_41597303的博客
11-19 268
Linux网络编程中的epoll和poll的函数说明与代码编写
poll模型
小神仙的博客
05-17 1242
poll模型poll系统调用的原理与原型和select基本类似，也是在指定时间内轮询一定数量的文件描述符，以测试其中是否有就绪者。poll改进了select模型，其一，不需要在修改传入的参数数组，其二，对于可以监控的个数不再局限于1024，可以通过cat /proc/sys/fs/file-max来查看。缺点：不能指定确定的那个sokect线程不安全poll模型的使用struct pollfd 结...
linux poll epoll
最新发布
10-09
poll和epoll都是Linux操作系统中用于I/O多路复用的机制。...epoll使用三个接口来完成其工作：epoll_create用于创建epoll模型，epoll_ctl用于添加/修改/删除文件描述符的监视事件，epoll_wait用于等待文件描述符就绪。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值