基于Boost.Asio协程的多连接Unix Socket回声服务器异常排查

常见故障原因及排查方向 #

• 重复绑定同一Unix Socket路径
  Unix Socket的绑定依赖文件系统路径，若多个监听器协程尝试绑定同一个路径，第二个及后续绑定会直接失败（除非路径对应的socket文件已被清理，或正确设置reuse_address选项）。可在绑定前调用unlink(path.c_str())删除残留的socket文件，同时添加错误检查捕获绑定失败信息：

  boost::system::error_code ec;
  acceptor.bind(endpoint, ec);
  if (ec) {
      std::cerr << "绑定失败: " << ec.message() << std::endl;
      return;
  }
  

• IO上下文提前退出
  若仅调用一次io_context.run()，当某个监听器协程因错误退出时，整个IO上下文会停止运行，导致其他监听器协程被强制终止。需用work_guard保持IO上下文持续运行，直到主动停止：

  auto work_guard = boost::asio::make_work_guard(io_context);
  

• 错误的多连接实现思路
  多连接处理无需启动多个监听器，单个监听器循环调用async_accept，为每个新连接独立spawn协程处理即可——这是Boost.Asio处理并发连接的标准模式，多个监听器绑定同一socket路径属于冗余操作，反而会引发冲突。

正确的多连接实现示例 #

#include <boost/asio.hpp>
#include <boost/asio/spawn.hpp>
#include <iostream>
#include <unistd.h>

namespace asio = boost::asio;

void handle_connection(asio::local::stream_protocol::socket socket, asio::yield_context yield) {
    try {
        char data[1024];
        for (;;) {
            boost::system::error_code ec;
            size_t n = socket.async_read_some(asio::buffer(data), yield[ec]);
            if (ec == asio::error::eof)
                break;
            else if (ec)
                throw boost::system::system_error(ec);

            asio::async_write(socket, asio::buffer(data, n), yield);
        }
    } catch (std::exception& e) {
        std::cerr << "连接处理异常: " << e.what() << std::endl;
    }
}

void do_listen(asio::io_context& io_context, const std::string& path, asio::yield_context yield) {
    asio::local::stream_protocol::acceptor acceptor(io_context);
    asio::local::stream_protocol::endpoint endpoint(path);

    // 清理残留的socket文件
    unlink(path.c_str());

    boost::system::error_code ec;
    acceptor.open(endpoint.protocol(), ec);
    if (ec) {
        std::cerr << "打开socket失败: " << ec.message() << std::endl;
        return;
    }

    acceptor.set_option(asio::socket_base::reuse_address(true));
    acceptor.bind(endpoint, ec);
    if (ec) {
        std::cerr << "绑定路径失败: " << ec.message() << std::endl;
        return;
    }

    acceptor.listen(asio::socket_base::max_listen_connections, ec);
    if (ec) {
        std::cerr << "监听失败: " << ec.message() << std::endl;
        return;
    }

    // 循环接受连接，每个连接启动独立协程处理
    for (;;) {
        asio::local::stream_protocol::socket socket(io_context);
        acceptor.async_accept(socket, yield);
        asio::spawn(io_context, [socket = std::move(socket)](asio::yield_context yield) mutable {
            handle_connection(std::move(socket), yield);
        });
    }
}

int main() {
    try {
        asio::io_context io_context;
        auto work_guard = asio::make_work_guard(io_context);

        // 启动单个监听器协程即可处理所有并发连接
        asio::spawn(io_context, [&](asio::yield_context yield) {
            do_listen(io_context, "/tmp/echo_socket", yield);
        });

        io_context.run();
    } catch (std::exception& e) {
        std::cerr << "全局异常: " << e.what() << std::endl;
    }
    return 0;
}

若确实需要多监听器（如监听不同路径） #

确保每个监听器绑定不同的Unix Socket路径，且所有监听器协程都在同一个IO上下文（或各自的IO上下文搭配独立运行线程）中启动，同时通过work_guard保证IO上下文不提前退出。

内容的提问来源于stack exchange，提问作者Zohar81