基于Boost.Beast的WebSocket客户端中ping/async_ping的正确使用方式问询

嘿，这个问题问到点子上了——Boost.Beast的WebSocket流操作规则很关键，尤其是在单线程异步环境里，稍不注意就会踩坑。我来一步步给你拆解：

核心原则先明确 #

首先要记住：Boost.Beast的websocket::stream是不可重入的，不管是同步还是异步操作，同一时间绝对不能存在多个未完成的IO操作。不管是async_write、async_read、ping还是async_ping，都必须等前一个操作完全完成（异步回调触发或同步方法返回）后，才能发起下一个。

问题1：能在有未完成async_write时调用ping或async_ping吗？ #

绝对不行！哪怕是单线程环境，这样做会导致未定义行为——可能破坏流的内部状态，引发数据错乱、崩溃或者莫名其妙的错误。必须等async_write的回调触发（确认写操作完成）后，再发起ping相关操作。

问题2：async_ping的正确调用方式 #

在异步环境里，调用async_ping的核心是确保没有任何未完成的异步操作，同时避免重复发起ping。具体有两种可靠的实现方式：

1. 链式回调模式：在每个异步操作的回调里发起下一个操作。比如完成async_write后，在它的回调函数里调用async_ping；等async_ping完成后，再继续后续的写操作或下一次ping。
2. 用strand序列化操作：在单线程环境中，strand可以帮你把所有IO操作排队，确保它们按顺序执行，不会并发。所有发起IO操作的逻辑都通过strand.post提交，哪怕多个地方同时触发操作，也会被strand按顺序处理。

另外要注意：

• async_ping的回调会接收一个error_code，必须处理它：如果成功，说明服务器已回复pong，连接正常；如果失败（比如连接断开、超时），需要处理重连或清理逻辑。
• 不要在一个async_ping未完成时发起另一个，可以维护一个简单的状态变量（比如bool is_ping_pending_），发起前检查，完成后重置。

问题3：同步ping的耗时与瓶颈问题 #

同步ping会阻塞当前线程，直到收到服务器的pong响应或触发超时（超时时间可通过set_option配置）。理论上的耗时是网络往返时间（RTT）加上服务器处理pong的时间，短则几毫秒，长则几秒（网络差或服务器卡顿的情况）。

在单线程异步环境里，这绝对是致命瓶颈！单线程异步的核心是让事件循环持续处理IO事件，而同步ping会卡住整个线程，导致这段时间内无法处理任何其他事件——比如 incoming的WebSocket消息、其他连接的IO操作，甚至定时器都会被阻塞，完全违背异步编程的初衷。所以异步环境里绝对不要用同步ping。

问题4：哪种方式更优？正确实现示例 #

在单线程异步环境里，必须优先使用async_ping。下面给你一个简单的实现示例，用strand序列化操作，同时维护操作状态：

class websocket_session : public std::enable_shared_from_this<websocket_session> {
public:
    explicit websocket_session(tcp::socket socket)
        : ws_(std::move(socket)), strand_(ws_.get_executor()) {}

    // 发起消息发送
    void send_message(std::string msg) {
        strand_.post([self=shared_from_this(), msg=std::move(msg)]() {
            self->write_queue_.push_back(std::move(msg));
            // 若当前无写操作，发起第一个写任务
            if(!self->is_writing_) {
                self->do_write();
            }
        });
    }

    // 发起ping操作
    void send_ping() {
        strand_.post([self=shared_from_this()]() {
            // 检查是否有pending的ping
            if(!self->is_ping_pending_) {
                self->is_ping_pending_ = true;
                // 发起async_ping，payload可自定义，也可用空buffer
                self->ws_.async_ping(boost::asio::buffer("custom_ping"),
                    std::bind(&websocket_session::on_ping, self, std::placeholders::_1));
            }
        });
    }

private:
    void do_write() {
        is_writing_ = true;
        ws_.async_write(boost::asio::buffer(write_queue_.front()),
            std::bind(&websocket_session::on_write, shared_from_this(), std::placeholders::_1, std::placeholders::_2));
    }

    void on_write(beast::error_code ec, std::size_t bytes_transferred) {
        is_writing_ = false;
        if(ec) {
            std::cerr << "写操作错误: " << ec.message() << std::endl;
            return;
        }
        write_queue_.pop_front();
        // 队列还有消息则继续写
        if(!write_queue_.empty()) {
            do_write();
        }
    }

    void on_ping(beast::error_code ec) {
        is_ping_pending_ = false;
        if(ec) {
            std::cerr << "Ping错误: " << ec.message() << std::endl;
            // 这里可以添加重连逻辑
            return;
        }
        // Ping成功，30秒后发起下一次Ping
        boost::asio::steady_timer timer(ws_.get_executor(), std::chrono::seconds(30));
        timer.async_wait([self=shared_from_this()](beast::error_code ec) {
            if(!ec) {
                self->send_ping();
            }
        });
    }

    websocket::stream<tcp::socket> ws_;
    boost::asio::strand<boost::asio::io_context::executor_type> strand_;
    std::deque<std::string> write_queue_;
    bool is_writing_ = false;
    bool is_ping_pending_ = false;
};

额外提个省心的建议：Boost.Beast支持自动发送ping的选项，你可以通过ws_.set_option(websocket::stream_base::ping_interval(std::chrono::seconds(30)))设置自动ping，库会自动管理ping的发送和pong的处理，除非你需要自定义ping payload或处理pong的特殊逻辑，否则这是更优的选择。

内容来源于stack exchange