C / C++ / 系统课时

处理事件删除与对象销毁

处理事件删除与对象销毁

Reactor 最危险的问题之一,不是收到事件,而是在回调执行过程中关闭连接、删除 Channel 或释放其所属对象。只要销毁顺序错一步,当前调用栈就可能继续访问已经失效的指针。本节用“延迟销毁”把事件注销、描述符关闭和对象释放拆成可验证的安全时序。

学习目标

  • 识别回调期间删除 Channel、关闭 fd 和释放对象造成的失效指针风险
  • 掌握“先停止监听,再离开分发栈,最后销毁对象”的安全顺序
  • 用延迟销毁避免重复 epoll_ctl、重复 close 和回调后的悬空访问

危险来自回调尚未结束

典型 Reactor 会先从 epoll_wait 得到活动事件,再逐个调用 Channel::handleEvent()。如果某个读回调发现对端关闭,直接 delete this 或立即释放持有 Channel 的连接对象,当前分发函数返回后仍可能访问该 Channel 的成员,形成 use-after-free。

回调期间立即销毁与延迟销毁的时序对比

安全原则可以概括成三层:先让内核不再关注它,再让当前调用栈停止使用它,最后释放内存。这三件事不能混成一个回调内立即完成的 closeConnection(),因为当前栈帧是否还持有对象指针,只有事件分发逻辑最清楚。

把销毁请求推迟到分发之后

下面的最小程序用一个 eventfd 模拟可读事件。Channel 的回调只提出销毁请求,EventLoop 等 handleEvent() 完整返回后,才执行 EPOLL_CTL_DEL、关闭 fd,并释放对象。将代码保存为 destroy_demo.cpp,使用支持 C++17 的 Linux 编译器编译运行。

cpp
#include <sys/epoll.h>
#include <sys/eventfd.h>
#include <unistd.h>

#include <cstdint>
#include <functional>
#include <iostream>
#include <memory>
#include <stdexcept>

class Channel {
public:
    explicit Channel(int fd) : fd_(fd) {}

    int fd() const { return fd_; }

    void setReadCallback(std::function<void()> cb) {
        readCallback_ = std::move(cb);
    }

    void handleEvent() {
        std::cout << "dispatch begin" << '\n';
        readCallback_();
        // 回调返回后对象必须仍然存活,否则这里可能访问悬空指针。
        std::cout << "dispatch end" << '\n';
    }

private:
    int fd_;
    std::function<void()> readCallback_;
};

class EventLoop {
public:
    EventLoop() {
        epollFd_ = epoll_create1(EPOLL_CLOEXEC);
        eventFd_ = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
        if (epollFd_ < 0 || eventFd_ < 0) {
            throw std::runtime_error("create fd failed");
        }

        channel_ = std::make_unique<Channel>(eventFd_);
        channel_->setReadCallback([this] {
            std::uint64_t value = 0;
            if (read(eventFd_, &value, sizeof(value)) != sizeof(value)) {
                throw std::runtime_error("read eventfd failed");
            }
            std::cout << "callback requests destroy" << '\n';
            destroyRequested_ = true;
        });

        epoll_event ev{};
        ev.events = EPOLLIN;
        ev.data.ptr = channel_.get();
        if (epoll_ctl(epollFd_, EPOLL_CTL_ADD, eventFd_, &ev) < 0) {
            throw std::runtime_error("epoll_ctl add failed");
        }
    }

    ~EventLoop() {
        if (channel_) {
            removeAndDestroy();
        }
        close(epollFd_);
    }

    void runOnce() {
        const std::uint64_t one = 1;
        if (write(eventFd_, &one, sizeof(one)) != sizeof(one)) {
            throw std::runtime_error("write eventfd failed");
        }

        epoll_event ev{};
        if (epoll_wait(epollFd_, &ev, 1, -1) != 1) {
            throw std::runtime_error("epoll_wait failed");
        }

        auto* active = static_cast<Channel*>(ev.data.ptr);
        active->handleEvent();

        // 只有离开 handleEvent 调用栈后,才真正释放 Channel。
        if (destroyRequested_) {
            removeAndDestroy();
        }
    }

private:
    void removeAndDestroy() {
        if (!channel_) {
            return;
        }

        const int fd = channel_->fd();
        if (epoll_ctl(epollFd_, EPOLL_CTL_DEL, fd, nullptr) < 0) {
            throw std::runtime_error("epoll_ctl del failed");
        }

        close(fd);
        eventFd_ = -1;
        channel_.reset();
        destroyRequested_ = false;
        std::cout << "channel destroyed safely" << '\n';
    }

    int epollFd_{-1};
    int eventFd_{-1};
    bool destroyRequested_{false};
    std::unique_ptr<Channel> channel_;
};

int main() {
    EventLoop loop;
    loop.runOnce();
}

预期输出:

text
dispatch begin
callback requests destroy
dispatch end
channel destroyed safely

这个输出验证了最关键的顺序:即使回调已经决定关闭连接,Channel 也会活到 handleEvent() 完成之后。

删除事件、关闭 fd 与释放对象的顺序

工程实现通常按固定顺序收口:回调先把连接状态改为 closing 并提出移除请求;EventLoop 在安全点执行 epoll_ctl(..., EPOLL_CTL_DEL, ...);当前活动事件分发结束后关闭 fd;最后释放持有 Channel 的连接对象或智能指针。

close(fd) 不能代替显式的生命周期管理。Linux 关闭 fd 后会处理其 epoll 关联,但应用层仍必须解决“活动事件数组里已经拿到的 data.ptr 是否还会被访问”这个问题。真正需要保护的是用户态对象生命周期,而不只是内核注册表。

防止同一对象被清理两次

连接关闭往往有多个入口:读到 EOF、写失败、超时、业务主动关闭都可能触发同一条清理路径。最简单的保护是让状态转换具备幂等性,例如只允许 Connected -> Closing -> Closed 单向前进。

不要让每个回调各自执行 epoll_ctl DEL、close 和 delete。更稳妥的做法是把清理统一收敛到 EventLoop 线程,由一个 removeChannel 或 destroyConnection 路径完成,并在入口检查当前状态。这样既避免重复系统调用,也避免不同线程同时释放同一对象。

当一轮 epoll_wait 返回多个活动 Channel 时,还要确保销毁一个对象不会让当前活动列表中的其他指针失效。常见做法是让活动列表只保存稳定引用,真正所有权由连接容器或智能指针持有;删除请求进入待处理队列,在本轮分发完成后统一回收。

最终要守住的是一条生命周期边界:回调可以决定对象“该死”,但不能在仍有人使用它时让它“立刻死”。把注销监听、关闭 fd 和释放内存分阶段执行,才能让 Reactor 在高并发关闭场景下保持稳定。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

处理事件删除与对象销毁

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通