PAYATHON 2026

在 boost::asio 中解耦数据包接收逻辑

数据小陈

结论

可以。需要解耦的是 socket 由谁创建和持有,以及收到数据报后交给谁处理;async_receive_from 本身不用改。UdpServer 可以只负责 socket 生命周期和异步接收循环。收到 datagram 后,通过回调、队列或 asio::post 把数据交给 AnotherPlace。Packet 的解析放在上层,不放进接收器。

为什么可以

Asio 的异步模型只要求异步操作发起后,在完成时调用完成处理程序。接收循环里再次调用 do_receive(),只是再发起一次异步操作,不会形成栈递归。完成处理程序里先把 bytes_recvd 对应的数据拷贝出来,交给其他对象处理就是安全的;成员 buffer 随后可以继续用于下一次 async_receive_from。

推荐做法

  1. 给 UdpServer 定义一个处理回调类型,例如 std::function<void(std::vector<std::uint8_t>, asio::ip::udp::endpoint)>。
  2. UdpServer 主要管三件事:持有和关闭 socket、发起 async_receive_from、把收到的字节和发送端 endpoint 交给回调。
  3. 上层 AnotherPlace 注册回调,在 packet_received 里构造并解析 Packet。
  4. 如果 socket 的创建也要解耦,可以让外部先创建 asio::ip::udp::socket,再移动传给 UdpServer。socket 不可复制,但可以移动。
  5. 如果 io_context 在多线程中 run(),用 asio::strand 或 asio::post 保护上层状态,避免多个完成处理程序同时进入 packet_received。

代码示例

class UdpServer {
public:
    using PacketHandler = std::function<void(std::vector<std::uint8_t>, asio::ip::udp::endpoint)>;

    UdpServer(asio::ip::udp::socket socket, PacketHandler handler)
        : socket_(std::move(socket)), handler_(std::move(handler)) {}

    void start() {
        do_receive();
    }

    void stop() {
        asio::error_code ec;
        socket_.close(ec);
    }

private:
    void do_receive() {
        socket_.async_receive_from(
            asio::buffer(buffer_), sender_endpoint_,
            [this](std::error_code ec, std::size_t bytes_recvd) {
                if (ec == asio::error::operation_aborted) {
                    return;
                }
                if (ec) {
                    std::cerr << ec.message() << std::endl;
                    return;
                }
                if (bytes_recvd > 0) {
                    std::vector<std::uint8_t> packet(
                        buffer_.data(), buffer_.data() + bytes_recvd);
                    handler_(std::move(packet), sender_endpoint_);
                }
                do_receive();
            });
    }

    asio::ip::udp::socket socket_;
    std::array<std::uint8_t, 65535> buffer_{};
    asio::ip::udp::endpoint sender_endpoint_;
    PacketHandler handler_;
};

class AnotherPlace {
public:
    AnotherPlace(asio::io_context& ctx, asio::ip::udp::socket socket)
        : server_(std::move(socket),
              [this](std::vector<std::uint8_t> data,
                     asio::ip::udp::endpoint from) {
                  packet_received(std::move(data), std::move(from));
              }) {}

    void start() {
        server_.start();
    }

    void packet_received(std::vector<std::uint8_t> data,
                         asio::ip::udp::endpoint from) {
        // 在这里按协议构造 Packet,并处理业务逻辑。
        // UdpServer 不关心 Packet 的格式。
    }

private:
    UdpServer server_;
};

// 外部创建 socket,再移动传入接收器
asio::io_context ctx;
asio::ip::udp::socket sock(
    ctx, asio::ip::udp::endpoint(asio::ip::udp::v4(), 9000));
AnotherPlace place(ctx, std::move(sock));
place.start();
ctx.run();

注意事项

  • 完成处理程序里的 buffer_ 是成员 buffer,下一次 async_receive_from 会复用它。示例中先拷贝到 std::vector 再调用回调;如果做零拷贝,必须保证数据在被处理前不会被下一次接收覆盖。
  • 在完成处理程序里再次调用 do_receive() 是继续发起异步接收,不会造成无限递归调用栈。但错误路径要有明确策略:遇到非 operation_aborted 错误时,是停止、重启还是记录后继续,需要按业务决定。
  • UdpServer 和 AnotherPlace 的生命周期要覆盖异步操作。stop() 或析构时关闭 socket,让未完成操作以 operation_aborted 返回,避免对象销毁后仍触发回调。
  • 如果多线程运行 io_context,handler_ 可能被并发调用。可以用 strand 串行化上层处理,或者把数据包投递到单线程队列。
  • 标准 Asio 的 async_receive_from 一次只接收一个 datagram,不能直接批量接收。解耦接收和业务处理不会改变这一点。Linux 下用 recvmmsg 需要走 native handle,可移植性要单独评估。

备注:内容仅供参考。