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 编译器编译运行。
#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();
}预期输出:
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 在高并发关闭场景下保持稳定。