计算机网络 / 系统课时
事件回调为什么容易失控
事件回调为什么容易失控
Reactor 把 I/O 事件转换成回调后,代码表面上很灵活,但连接状态、错误处理和对象寿命也容易散落到不同 lambda 中。本节把回调重新收拢到事件处理器,让每次网络事件都围绕同一个连接状态机处理。
学习目标
- 识别回调嵌套、状态分散和对象生命周期失控的典型原因
- 理解“回调负责转发、处理器负责状态”的组织方式
- 能用弱引用避免 EventLoop 与连接对象形成错误生命周期关系
问题不在回调本身
一个 readable 回调只做少量工作时并不危险。问题通常出现在它开始同时修改连接状态、安排写事件、处理关闭、调用业务逻辑,并继续注册新的匿名回调。久而久之,同一条连接的状态被分散在多个函数和捕获变量里。
此时维护者很难回答三个问题:当前连接处于什么状态、某个事件是否仍然允许处理、回调执行时对象是否还活着。这三个问题一旦分散,异常关闭和并发修改就很容易触发悬空引用或重复清理。

让回调只做事件入口
更稳定的组织方式是让 EventLoop 保存很薄的回调,真正的状态判断放进 ConnectionHandler。这样读事件、关闭事件和错误事件最终都落到同一个对象上,状态修改也集中在一个地方。
下面的完整示例还使用 std::weak_ptr。事件循环触发回调时先尝试获得对象的临时所有权;如果连接已经销毁,就直接忽略事件,从而避免回调捕获裸指针后访问失效对象。
#include <functional>
#include <iostream>
#include <memory>
#include <string>
#include <unordered_map>
class EventLoop {
public:
using Callback = std::function<void()>;
void registerReadable(int fd, Callback callback) {
readable_[fd] = std::move(callback);
}
void fireReadable(int fd) {
auto it = readable_.find(fd);
if (it != readable_.end()) {
it->second();
}
}
private:
std::unordered_map<int, Callback> readable_;
};
class ConnectionHandler : public std::enable_shared_from_this<ConnectionHandler> {
public:
enum class State { Established, Closed };
static std::shared_ptr<ConnectionHandler> create(EventLoop& loop, int fd) {
auto handler = std::shared_ptr<ConnectionHandler>(
new ConnectionHandler(loop, fd));
handler->registerEvents();
return handler;
}
void receive(std::string data) {
pendingData_ = std::move(data);
}
void markPeerClosed() {
peerClosed_ = true;
}
private:
ConnectionHandler(EventLoop& loop, int fd)
: loop_(loop), fd_(fd), state_(State::Established) {
std::cout << "state=ESTABLISHED" << std::endl;
}
void registerEvents() {
std::weak_ptr<ConnectionHandler> weakSelf = shared_from_this();
loop_.registerReadable(fd_, [weakSelf] {
// EventLoop 不拥有连接;对象仍存活时才进入处理器。
if (auto self = weakSelf.lock()) {
self->onReadable();
}
});
}
void onReadable() {
if (state_ == State::Closed) {
return;
}
if (peerClosed_) {
std::cout << "peer closed" << std::endl;
close();
return;
}
// 数据、状态和关闭判断都集中在同一个连接对象中。
std::cout << "read=" << pendingData_ << std::endl;
pendingData_.clear();
}
void close() {
state_ = State::Closed;
std::cout << "state=CLOSED" << std::endl;
}
EventLoop& loop_;
int fd_;
State state_;
std::string pendingData_;
bool peerClosed_ = false;
};
int main() {
EventLoop loop;
auto connection = ConnectionHandler::create(loop, 101);
connection->receive("hello");
loop.fireReadable(101);
connection->markPeerClosed();
loop.fireReadable(101);
}预期输出
state=ESTABLISHED
read=hello
peer closed
state=CLOSED状态应该有唯一归属
如果读取回调维护一个 closed 标志,写回调再维护一个 closing 标志,错误回调又直接释放对象,那么状态实际上没有唯一来源。更好的做法是让连接处理器持有状态、输入输出缓冲以及关闭原因,所有事件先检查当前状态再决定动作。
状态集中后,规则也更容易表达。例如连接进入 Closed 后不再处理读写事件;准备关闭时先决定是否冲刷剩余写缓冲;错误事件与对端关闭最终都通过同一个关闭入口完成资源释放。
生命周期要与回调注册解耦
事件循环经常比单条连接活得更久,因此不能简单让每个注册回调永久持有 shared_ptr,否则 EventLoop 持有回调、回调持有 Connection,连接即使业务上已经关闭也可能无法析构。
使用弱引用是一种常见办法:回调触发时临时 lock,成功才处理事件。真实 Reactor 还应在关闭连接时主动从 poller 中注销 fd,而不是仅依赖弱引用忽略过期事件。
判断回调设计是否已经失控
当一个事件回调需要直接知道多个其他回调的局部状态,或者关闭逻辑在读、写、错误分支里各复制一份,通常就应该收拢。回调最好只承担“哪个事件发生了”的通知职责,连接处理器负责“当前状态下该怎么办”。
这种组织方式不会消除异步复杂度,但会把复杂度限制在可追踪的对象和状态转换里。后续增加写缓冲、超时、背压或半关闭时,只需继续扩展连接处理器的状态规则,而不必继续堆叠彼此捕获的匿名回调。