计算机网络 / 系统课时

事件回调为什么容易失控

事件回调为什么容易失控

Reactor 把 I/O 事件转换成回调后,代码表面上很灵活,但连接状态、错误处理和对象寿命也容易散落到不同 lambda 中。本节把回调重新收拢到事件处理器,让每次网络事件都围绕同一个连接状态机处理。

学习目标

  • 识别回调嵌套、状态分散和对象生命周期失控的典型原因
  • 理解“回调负责转发、处理器负责状态”的组织方式
  • 能用弱引用避免 EventLoop 与连接对象形成错误生命周期关系

问题不在回调本身

一个 readable 回调只做少量工作时并不危险。问题通常出现在它开始同时修改连接状态、安排写事件、处理关闭、调用业务逻辑,并继续注册新的匿名回调。久而久之,同一条连接的状态被分散在多个函数和捕获变量里。

此时维护者很难回答三个问题:当前连接处于什么状态、某个事件是否仍然允许处理、回调执行时对象是否还活着。这三个问题一旦分散,异常关闭和并发修改就很容易触发悬空引用或重复清理。

事件回调收拢为连接处理器状态机

让回调只做事件入口

更稳定的组织方式是让 EventLoop 保存很薄的回调,真正的状态判断放进 ConnectionHandler。这样读事件、关闭事件和错误事件最终都落到同一个对象上,状态修改也集中在一个地方。

下面的完整示例还使用 std::weak_ptr。事件循环触发回调时先尝试获得对象的临时所有权;如果连接已经销毁,就直接忽略事件,从而避免回调捕获裸指针后访问失效对象。

cpp
#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);
}

预期输出

text
state=ESTABLISHED
read=hello
peer closed
state=CLOSED

状态应该有唯一归属

如果读取回调维护一个 closed 标志,写回调再维护一个 closing 标志,错误回调又直接释放对象,那么状态实际上没有唯一来源。更好的做法是让连接处理器持有状态、输入输出缓冲以及关闭原因,所有事件先检查当前状态再决定动作。

状态集中后,规则也更容易表达。例如连接进入 Closed 后不再处理读写事件;准备关闭时先决定是否冲刷剩余写缓冲;错误事件与对端关闭最终都通过同一个关闭入口完成资源释放。

生命周期要与回调注册解耦

事件循环经常比单条连接活得更久,因此不能简单让每个注册回调永久持有 shared_ptr,否则 EventLoop 持有回调、回调持有 Connection,连接即使业务上已经关闭也可能无法析构。

使用弱引用是一种常见办法:回调触发时临时 lock,成功才处理事件。真实 Reactor 还应在关闭连接时主动从 poller 中注销 fd,而不是仅依赖弱引用忽略过期事件。

判断回调设计是否已经失控

当一个事件回调需要直接知道多个其他回调的局部状态,或者关闭逻辑在读、写、错误分支里各复制一份,通常就应该收拢。回调最好只承担“哪个事件发生了”的通知职责,连接处理器负责“当前状态下该怎么办”。

这种组织方式不会消除异步复杂度,但会把复杂度限制在可追踪的对象和状态转换里。后续增加写缓冲、超时、背压或半关闭时,只需继续扩展连接处理器的状态规则,而不必继续堆叠彼此捕获的匿名回调。

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

目录与阅读设置

阅读设置

17

记录一个想法

事件回调为什么容易失控

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

登录哪都通