(十四)支持多种IO多路复用的技术

最新推荐文章于 2025-07-23 14:26:41 发布
原创 最新推荐文章于 2025-07-23 14:26:41 发布 · 置顶 · 893 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#libevent #多路I-O #集成

本文详细解析了libevent库如何通过统一的接口支持多种I/O多路复用机制，特别是针对epoll的具体实现细节。

前言

众所周知,libevent支持多种I/O多路复用,如select、poll、epoll、kqueue等。那么其中是如何实现的呢？
主要就是结构体eventop,它内部成员有几个函数指针,统一了每种I/O多路复用的接口,也就是说,要想libevent支持某种I/O多路复用,就必须实现这几种接口。结构体eventop位于event-internal.h中。

eventop

struct eventop
{
  const char *name;
  void *(*init)(struct event_base *); //初始化
  int (*add)(void *, struct event *); //添加事件
  int (*del)(void *, struct event *); //删除事件
  int (*dispatch)(struct event_base *, void *, struct timeval *); //分发事件
  void (*dealloc)(struct event_base *, void *); //释放资源
  int need_reinit;
};

这5个函数指针分别指向某个具体的多路I/O复用机制的初始化、添加事件、删除事件、分发事件、释放资源这5个操作上。这样,libevent就可以支持该多路I/O复用机制了。
但是其实我们使用的时候并没有选择用哪一种,说明是有默认选项的。

在event.c文件中,有一个静态全局的eventops数组,并且按照优先级选择用哪一种多路I/O复用机制。定义如下:

static const struct eventop *eventops[] = {
#ifdef HAVE_EVENT_PORTS
        &evportops,
#endif
#ifdef HAVE_WORKING_KQUEUE
        &kqops,
#endif
#ifdef HAVE_EPOLL
        &epollops,
#endif
#ifdef HAVE_DEVPOLL
        &devpollops,
#endif
#ifdef HAVE_POLL
        &pollops,
#endif
#ifdef HAVE_SELECT
        &selectops,
#endif
#ifdef WIN32
        &win32ops,
#endif  
        NULL
};

这里主要运用了条件编译,在config.h中define了可以支持的多路I/O复用,由于只是简单的define,并且代码比较多,就不在这里列举了,可以自己看一看。

epollops

接下来,我们以epoll为例来看一看epollops的真面目。
在epoll.c文件中：

const struct eventop epollops = {
    "epoll",
    epoll_init,
    epoll_add,
    epoll_del,
    epoll_dispatch,
    epoll_dealloc,
    1 /* need reinit */
  };

那么只用实现epoll_init、epoll_add、epoll_del、epoll_dispatch、epoll_dealloc这几个函数就行了。
首先先看一下这几个函数要用到的结构体

//对应读和写事件
struct evepoll {
    struct event *evread;
    struct event *evwrite;
};

struct epollop {
    //每个fd可对应读/写事件
    struct evepoll *fds;
    //fd的数量
    int nfds;
    //epoll事件
    struct epoll_event *events;
    //事件的数量
    int nevents;
    //epoll专用文件描述符
    int epfd;
};

epoll_init

接下来是epoll_init:

static void *
epoll_init(struct event_base *base)
{
    int epfd;
    struct epollop *epollop;

    /* Disable epollueue when this environment variable is set */
    if (evutil_getenv("EVENT_NOEPOLL"))
        return (NULL);

    /* Initalize the kernel queue */
    //创建epoll句柄
    if ((epfd = epoll_create(32000)) == -1) {
        if (errno != ENOSYS)
            event_warn("epoll_create");
        return (NULL);
    }
    //这是为了防止在使用多进程时,子进程继承父进程打开的文件描述符及权限。所以设置FD_CLOEXEC标志。
    FD_CLOSEONEXEC(epfd);
    //给epollop申请空间
    if (!(epollop = calloc(1, sizeof(struct epollop))))
        return (NULL);

    epollop->epfd = epfd;

    /* Initalize fields */
    epollop->events = malloc(INITIAL_NEVENTS * sizeof(struct epoll_event));
    //当申请空间失败时,把之前申请的也释放了,然后return
    if (epollop->events == NULL) {
        free(epollop);
        return (NULL);
    }
    epollop->nevents = INITIAL_NEVENTS;

    epollop->fds = calloc(INITIAL_NFILES, sizeof(struct evepoll));
    //同理
  if (epollop->fds == NULL) {
        free(epollop->events);
        free(epollop);
        return (NULL);
    }
    epollop->nfds = INITIAL_NFILES;
    //由于libevent为了将signal也集成到事件主循环中,所以使用了套结字对(socket pair)。这个函数就用于创建socket pair和初始化evsignal_info
    evsignal_init(base);

    return (epollop);
}

epoll_add

epoll_add:

static int
epoll_add(void *arg, struct event *ev)
{
    struct epollop *epollop = arg;
    struct epoll_event epev = {0, {0}};
    struct evepoll *evep;
    int fd, op, events;

    //如果是signal事件,直接调用evsignal_add来添加就行了
    if (ev->ev_events & EV_SIGNAL)
        return (evsignal_add(ev));

    fd = ev->ev_fd;
    //当前的文件描述符大于nfds时,需要重新扩展。(这点是利用了linux系统优先分配空闲的最小值fd)
    if (fd >= epollop->nfds) {
        /* Extent the file descriptor array as necessary */
        if (epoll_recalc(ev->ev_base, epollop, fd) == -1)
            return (-1);
    }
    //evep是当前fd(需要add的)对应的struct evepoll(里面是读/写事件)
    evep = &epollop->fds[fd];
    //对应的默认操作是添加操作
    op = EPOLL_CTL_ADD;
    events = 0;
    //如果已经指向了一个读事件,证明该fd已经在epoll监听中了,所以应该将操作改为EPOLL_CTL_MOD,但是为了防止以前的监听读事件标志被覆盖,所以重新加上。
    if (evep->evread != NULL) {
        //监听读事件
        events |= EPOLLIN;
        op = EPOLL_CTL_MOD;
    }
    //同理
    if (evep->evwrite != NULL) {
        events |= EPOLLOUT;
        op = EPOLL_CTL_MOD;
    }
    //如果设置了EV_READ标志,说明是读事件
    if (ev->ev_events & EV_READ)
        events |= EPOLLIN;
    //如果设置了EV_WRITE标志,说明是写事件
    if (ev->ev_events & EV_WRITE)
        events |= EPOLLOUT;

    //设置struct epoll_event
    epev.data.fd = fd;
    epev.events = events;
    //修改/增加fd到监听的epollop->epfd中去
    if (epoll_ctl(epollop->epfd, op, ev->ev_fd, &epev) == -1)
            return (-1);

    /* Update events responsible */
    //如果是读事件,那么让evread指向该event
    if (ev->ev_events & EV_READ)
        evep->evread = ev;
    //如果是写事件,那么让evwrite指向该event
    if (ev->ev_events & EV_WRITE)
        evep->evwrite = ev;

    return (0);
}

epoll_dispatch

接下来便是最复杂的epoll_dispatch了:

static int
epoll_dispatch(struct event_base *base, void *arg, struct timeval *tv)
{
    struct epollop *epollop = arg;
    struct epoll_event *events = epollop->events;
    struct evepoll *evep;
    int i, res, timeout = -1;
    //如果设置了超时等待时间,那么就将这时间具体多少ms算出来
    if (tv != NULL)
        timeout = tv->tv_sec * 1000 + (tv->tv_usec + 999) / 1000;
    //如果该等待时间大于了最长的等待时间,那就直接设置为最长等待时间(该最长等待时间是epoll.c里面设定的)
    //#define MAX_EPOLL_TIMEOUT_MSEC (35*60*1000)
    //即最久等35分钟.....不过可以自己修改
    if (timeout > MAX_EPOLL_TIMEOUT_MSEC) {
        /* Linux kernels can wait forever if the timeout is too big;
         * see comment on MAX_EPOLL_TIMEOUT_MSEC. */
        //linux内核是可以无限等的,但是关键还是看MAX_EPOLL_TIMEOUT_MSEC
        timeout = MAX_EPOLL_TIMEOUT_MSEC;
    }

    //epoll_wait函数我相信你应该懂的,返回值是触发了的事件总数
    res = epoll_wait(epollop->epfd, events, epollop->nevents, timeout);
    //返回-1代表出错了
    if (res == -1) {
        //如果不是被信号中断的,那么直接报错了
        if (errno != EINTR) {
            event_warn("epoll_wait");
            return (-1);
        }
        //处理signal事件
        evsignal_process(base);
        return (0);
    } else if
    //查看是否有信号的标志,如若发生,则处理signal事件
   (base->sig.evsignal_caught) {
        evsignal_process(base);
    }

    event_debug(("%s: epoll_wait reports %d", __func__, res));
    //依次处理被触发的事件
    for (i = 0; i < res; i++) {
        //what：记录什么类型的事件
        int what = events[i].events;
        struct event *evread = NULL, *evwrite = NULL;
        int fd = events[i].data.fd;

        if (fd < 0 || fd >= epollop->nfds)
            continue;
        evep = &epollop->fds[fd];
        //如果是被挂断或者出错导致被触发
        if (what & (EPOLLHUP|EPOLLERR)) {
            evread = evep->evread;
            evwrite = evep->evwrite;
        } else {
            if (what & EPOLLIN) {
                evread = evep->evread;
            }

            if (what & EPOLLOUT) {
                evwrite = evep->evwrite;
            }
        }
        //如果读/写事件都没有,直接结束本次循环
        if (!(evread||evwrite))
            continue;
        //手动激活读/写事件
        if (evread != NULL)
            event_active(evread, EV_READ, 1);
        if (evwrite != NULL)
            event_active(evwrite, EV_WRITE, 1);
    }
    //当nevents不够用的时候,重新分配
    if (res == epollop->nevents && epollop->nevents < MAX_NEVENTS) {
        /* We used all of the event space this time.  We should
           be ready for more events next time. */
        int new_nevents = epollop->nevents * 2;
        struct epoll_event *new_events;

        new_events = realloc(epollop->events,
            new_nevents * sizeof(struct epoll_event));
        if (new_events) {
            epollop->events = new_events;
            epollop->nevents = new_nevents;
        }
    }

    return (0);
}

注意epoll_dispatch函数中并没有调用处理事件的业务,而是在event_base_loop中由event_process_actice调用。相当于它的工作是只负责把事件添加到激活队列中,然后由event_process_actice处理。

接下来只剩epoll_del和epoll_dealloc还有epoll_recalc了,epoll_del的逻辑和epoll_add大致相似,就不在这里列出了。而epoll_recalc无非就是重新分配内存,也没什么需要注意的,最后就来个epoll_dealloc收尾吧。

epoll_dealloc

epoll_dealloc:

static void
epoll_dealloc(struct event_base *base, void *arg)
{
    struct epollop *epollop = arg;

    evsignal_dealloc(base);
    if (epollop->fds)
        free(epollop->fds);
    if (epollop->events)
        free(epollop->events);
    if (epollop->epfd >= 0)
        close(epollop->epfd);

    //释放了空间之后,别忘了将指针指向的地方赋为null,不然指向的是已经释放了的空间,造成野指针
    memset(epollop, 0, sizeof(struct epollop));
    free(epollop);
}

这里我们来关注一下void *arg,前面已经出现过多次,可能你会对其产生疑惑,而在event_init中的函数类型也是void *,而返回的是struct epollop *,在event_add或者event_base_loop中,调用的都是evsel->add(evbase, ev)或者evsel->dispatch(base, evbase, tv_p)这样的,这说明每一个多路I/O复用都对应有它自己的struct xxxop *。之所以返回值是void *,是为了将不同的struct xxxop *转换成统一的指针类型。

小结

在本节中,我们终于知道了神秘的libevent如何同时支持了那么多种多路I/O复用机制,再配合上前面讲的主循环以及event还有event_base以及信号、定时事件。你应该可以跟着事件的主循环,在脑海中浮现出一个一个的事件是如何被添加到事件链表,以及被激活,等待调度,调度之后被销毁等等的场景了。
接下来,我们将研究libevent库中缓冲区的部分。

Redis与IO多路复用
微刻
11-14 1686
IO多路复用是一种处理并发IO请求的技术，它允许单个线程监视多个文件描述符（file descriptors），以确定哪些文件描述符已经准备好进行IO操作。这项技术的核心在于能够在单个线程中高效地处理多个并发连接，而无需为每个连接创建一个线程。定义：IO多路复用模型允许一个线程处理多个输入/输出通道。当某个通道有数据可读或可写时，该线程会被通知，然后执行相应的操作。提高效率：通过IO多路复用，Redis能够使用一个线程来管理多个客户端连接，减少了线程创建和销毁的开销，提高了资源利用率和系统吞吐量。
网络编程学习——IO多路复用
qq_41934502的博客
04-21 1002
多路复用接口学习
多路复用（
geiii9的博客
04-12 2823
apue 多路复用
IO模式与IO多路复用
墨1024
11-12 1125
说明了 I/O多路复用 select 、poll、epoll的原理与用法 介绍了了5种I/O模式： - 阻塞 I/O（blocking IO） BIO - 非阻塞 I/O（nonblocking IO） NIO - I/O 多路复用（ IO multiplexing） - 信号驱动 I/O（ signal driven IO） - 异步 I/O（asynchronous IO）
proxy_set_header设置Host为$proxy_host，$host与$local_host的区别
zzhongcy的专栏
03-25 4万+
先来看下proxy_set_header的语法 语法: proxy_set_headerfieldvalue; 默认值: proxy_set_header Host $proxy_host; proxy_set_header Connection close; 上下文: http,server,location 允许重新定义...
nginx 反向代理 tomcat (https、虚拟主机)
weixin_33924770的博客
11-08 573
背景： 有一个JSP开发的网站，需要放在tomcat里面运行，考虑到tomcat处理http请求不是那么强，计划前端添加一个nginx作为反向代理，并且提供https服务，并且通过虚拟主机开代理到指定域名的服务。 我们的域名是www.wzlinux.com。 1、首先是安装nginx和tomcat 2、nginx配置文件如下 包含3...
Nginx的proxy_set_header设置问题
王景清的博客
01-19 1万+
Host 直接访问 浏览器直接访问服务器 结果：浏览器访问IP+端口 通过Nginx代理访问(不做任何配置) 通过Nginx反向代理，不配置proxy_set_header。 server { listen 8090; server_name _; location / { proxy_pass http://172.31.5.0:5000; } } 结果：proxy_pass+代理端口，即代理IP+代理端口。 $host 设置proxy_set_hea
redis IO多路复用机制
水w的博客
10-17 2865
redis IO多路复用机制
Java中IO多路复用技术详解
最新发布
持续输出Java相关知识
07-23 2681
Java中的IO多路复用是实现高性能、高并发服务器的核心技术之一。本文全面深入剖析Java中IO多路复用的底层原理、NIO核心组件（Channel、Buffer、Selector）、非阻塞编程模型、以及实际案例中的应用场景，辅以丰富的示例代码讲解每个知识点，帮助读者彻底掌握Java NIO体系与实战能力。
09-Redis IO 多路复用
javaTalk
04-18 2259
目录 一 Redis 是单线程还是多线程？ 二 为什么单线程的 Redis 性能很高？ 三 什么是 IO 多路复用技术？ 一 Redis 是单线程还是多线程？ 这个问题可以一分为二： Redis 是单线程，是因为 Redis 使用文件事件分派器来处理事件队列，且该文件事件分派器是单线程的，所以 Redis 才叫做单线程的模型。 Redis 是多线程，是因为持久化、异步删除、集群数据同步等操作都是由数据读写线程之外其他线程执行的，所以 Redis 也可以叫做多线程模型。 之所以大家都说是单线程
proxy_set_header Host $host $proxy_port $http_host
热门推荐
04-15 4万+
proxy_set_header Host $host $proxy_port $http_host 浏览器直接访问服务，获取到的 Host 包含浏览器请求的 IP 和端口。 app.run(host='192.168.88.99', port=9494) 结果如下： { Host:"192.168.88.99:9494" } 配置 nginx 代理服务后 不设置 proxy_set_header Host 时，浏览器直接访问 nginx，获取到的 Host 是 proxy_pas
关于 Nginx 配置中 proxy_set_header Host $host 的作用及其对 HTTP 请求头影响的详细说明，结合示例展示设置前后的差异
weixin_42279822的博客
03-31 4108
可以避免因请求头不匹配导致的错误，确保反向代理的稳定性和安全性。以下是关于 Nginx 配置中。在 Nginx 反向代理配置中，
nginx 配置来做http代理、负载均衡、tcp代理转发
qq_39458487的博客
03-28 5041
一、nginx http 代理 nginx http 代理 通过proxy_set_header，返回客户端真实IP地址及端口，而不是代理主机ip #proxy ngx 代理不支持 https，有https需求可以用squid server { listen 9998; allow 192.168.0.0/24; deny all; location / { access_log /data/logs/proxy_access.log main; ...
nginx之配置proxy_set_header
weixin_44316575的博客
01-03 3902
nginx之配置proxy_set_header win10客户端请求web服务，win10的ip：192.168.223.1 nginx作为反向代理服务器：192.168.223.136 nginx作为后端web服务器：192.168.223.137 前提条件：配置nginx转发到后端服务器 server { listen 8080; server_name 192.168.223.136; l...
nginx 关于 proxy_set_header Host $host 信息验证
zyy247796143的博客
09-03 4323
测试环境 nginx 服务器 IP：192.168.4.20 web 服务器IP：192.168.4.5 配置详情 1. 在 web 服务器(192.168.4.5)上启动简易 Flask 服务来获取Host 信息。编辑req.py： from flask import Flask from flask import request app = Flask(__name__) @app.route('/') def getrequest(): useragent=request.headers.
Nginx反向代理：$host与$proxy_host深度解析
爱的叹息的专栏
05-15 1384
在 Nginx 反向代理配置中，proxy_set_header Host $host 和 proxy_set_header Host $proxy_host 用于设置发送给后端服务器的 Host 请求头，但两者有显著区别。$host 来自客户端请求头，通常为用户访问的域名，适用于多域名路由或虚拟主机场景；而 $proxy_host 来自 Nginx 配置的 proxy_pass 地址，通常为 IP:PORT 或域名，适用于单一后端服务或需要避免 Host 头攻击的场景。$host 可被客户端篡改，安全性较
Nginx proxy_set_header参数设置
duanghuang的博客
10-11 2889
不设置 proxy_set_header Host 时，浏览器直接访问 nginx，获取到的 Host 是 proxy_pass 后面的值，即 $proxy_host 的值，参考。
proxy_set_header Host $host；
az44yao的专栏
07-25 450
server {#核心代码。
nginx中proxy_set_header Host $host的作用
weixin_34311757的博客
04-28 315
nginx为了实现反向代理的需求而增加了一个ngx_http_proxy_module模块。其中proxy_set_header指令就是该模块需要读取的配置文件。在这里，所有设置的值的含义和http请求同中的含义完全相同，除了Host外还有X-Forward-For。Host的含义是表明请求的主机名，因为nginx作为反向代理使用，而如果后端真是的服务器设置有类似防盗...
io多路复用技术
07-13
IO多路复用是一种高效的网络编程技术，它允许单个线程同时监视多个输入/输出（I/O）通道，并在其中任何一个通道变为可读或可写时立即得到通知。这种机制使得程序能够高效地处理大量并发连接，而不需要为每个连接分配独立的线程或者进程。 ### 原理详解 在传统的阻塞式 I/O 模型中，如果一个线程正在等待某个文件描述符上的数据到达，则该线程会一直被阻塞，直到数据准备好并且被读取完毕。这种方式对于少量的连接是可行的，但当需要处理成千上万的连接时，就会导致资源浪费和性能下降。 IO多路复用通过使用特定的系统调用如 `select`、`poll` 或者更现代的 `epoll` (Linux) 和 `kqueue` (BSD) 来解决这个问题。这些系统调用可以监听一组文件描述符，一旦集合中的任一描述符就绪（即可以进行读写操作），它们就会返回给应用程序进行相应的处理。这样做的好处是可以避免不必要的轮询以及减少上下文切换带来的开销。 例如，在使用 `epoll` 时，内核维护了一个事件表，每当有新的事件发生时，比如客户端发送了数据过来，`epoll_wait` 调用就会返回那些已经准备好的文件描述符列表，从而让服务端可以针对性地对这些就绪的连接执行读写操作 [^4]。 ### 使用场景分析 - **高并发服务器**：当构建Web服务器、数据库服务器等需要支持大量并发用户的场景下，采用IO多路复用技术能显著提高效率。它可以确保即使面对数以万计的同时连接，也能保持较低的延迟和较高的吞吐量。 - **实时通信应用**：像即时消息传递系统或是在线游戏这类要求快速响应的应用场合，利用IO多路复用可以帮助实现低延迟的消息传递与交互体验优化 [^1]。 - **混合协议处理**：若某一服务需同时处理TCP与UDP流量，或是涉及多种网络协议的情况，IO多路复用提供了一种统一管理不同类型的网络连接的方法 [^2]。 - **资源受限环境**：在内存或其他计算资源有限制的情况下，比如嵌入式设备上运行的服务，采用此技术有助于节省系统资源消耗，因为不需要为每一个连接创建额外的工作线程 [^3]。 综上所述，IO多路复用不仅解决了传统多线程模型中存在的诸多问题，而且非常适合用来开发高性能、大规模并发处理能力的服务端软件。通过对底层操作系统提供的API的有效利用，开发者能够编写出既稳定又高效的网络应用程序。 ```c // 示例代码 - 使用 epoll 创建简单的 IO 多路复用示例 #include <sys/epoll.h> #include <unistd.h> #include <stdio.h> #define MAX_EVENTS 10 int main() { int epfd = epoll_create1(0); // 创建 epoll 文件描述符 if (epfd == -1) { perror("epoll_create1"); return 1; } struct epoll_event ev, events[MAX_EVENTS]; ev.events = EPOLLIN; // 监听读事件 ev.data.fd = STDIN_FILENO; // 标准输入作为监听对象 if (epoll_ctl(epfd, EPOLL_CTL_ADD, STDIN_FILENO, &ev) == -1) { // 添加到epoll监控 perror("epoll_ctl: add"); return 1; } while (1) { int nfds = epoll_wait(epfd, events, MAX_EVENTS, -1); // 等待事件触发 for (int i = 0; i < nfds; ++i) { if (events[i].data.fd == STDIN_FILENO) { char buffer[128]; ssize_t count = read(STDIN_FILENO, buffer, sizeof(buffer)); // 读取标准输入 if (count > 0) { printf("Read %zd bytes: %.*s\n", count, (int)count, buffer); } } } } close(epfd); return 0; } ``` 这段C语言代码展示了如何使用`epoll`来设置一个简单的IO多路复用实例，这里监听的是标准输入流。当用户向终端输入数据时，程序将捕获这一事件并打印接收到的内容。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值