C++中执行两个阻塞IO调用的更轻量化方案

嘿，这个场景我太熟悉了——单核心CPU下跑两个阻塞IO的双线程方案，其实反而会拖慢你的程序，因为线程切换的开销完全没必要。让我给你拆解问题，再给两个更高效的实现思路：

你的两个任务都是阻塞IO调用，意味着线程大部分时间都在等待网络数据，而非占用CPU计算。在单核心环境下，双线程的上下文切换（保存/恢复线程栈、寄存器状态等）会额外消耗CPU资源，反而抵消了"并行"处理IO的优势——毕竟单核心同一时间只能跑一个线程，切换的开销纯纯是浪费。

这是IO密集型场景下的经典优化思路，用单线程就能处理多个异步IO任务：

• 把两个网络套接字设置为非阻塞模式，这样调用读取接口时不会卡住线程，而是立即返回状态
• 用事件多路复用工具（比如Linux的epoll、Windows的IOCP，或者跨平台库如Boost.Asio）监听两个套接字的"可读"事件
• 当某个套接字有数据就绪时，再执行读取和处理逻辑，处理完后回到事件循环继续等待

举个Boost.Asio的简化示例（跨平台友好）：

#include <boost/asio.hpp>
#include <iostream>
#include <vector>

using namespace boost::asio;

int main() {
    io_context io;
    ip::tcp::socket sock1(io);
    ip::tcp::socket sock2(io);

    // 假设已完成两个socket的连接逻辑...

    // 定义异步读取回调
    auto read_handler = [](const boost::system::error_code& ec, std::size_t bytes_read, ip::tcp::socket& sock) {
        if (!ec) {
            std::cout << "从socket读取到 " << bytes_read << " 字节数据\n";
            // 处理数据并返回结果...
            // 继续监听下一次可读事件
            sock.async_read_some(buffer(std::vector<char>(1024)), 
                std::bind(read_handler, std::placeholders::_1, std::placeholders::_2, std::ref(sock)));
        }
    };

    // 启动两个socket的异步读取
    sock1.async_read_some(buffer(std::vector<char>(1024)), 
        std::bind(read_handler, std::placeholders::_1, std::placeholders::_2, std::ref(sock1)));
    sock2.async_read_some(buffer(std::vector<char>(1024)), 
        std::bind(read_handler, std::placeholders::_1, std::placeholders::_2, std::ref(sock2)));

    io.run(); // 单线程运行事件循环，处理所有IO事件
    return 0;
}

如果你的项目能用到C++20或更高版本，协程是更优雅的选择——它是用户态的轻量级执行单元，切换开销几乎可以忽略：

• 用协程封装阻塞IO逻辑，当IO需要等待时，协程会主动挂起，让出CPU给其他协程
• 整个程序仍然在单线程中运行，避免了操作系统级的线程切换

还是用Boost.Asio的协程支持来举例（简化版）：

#include <boost/asio.hpp>
#include <boost/asio/spawn.hpp>
#include <iostream>
#include <vector>

using namespace boost::asio;

// 协程函数：处理单个socket的读取
void handle_socket_read(ip::tcp::socket& sock, yield_context yield) {
    std::vector<char> buf(1024);
    boost::system::error_code ec;

    while (true) {
        // 异步读取，协程会在IO等待时挂起
        std::size_t bytes_read = sock.async_read_some(buffer(buf), yield[ec]);
        if (ec) break;

        std::cout << "从socket读取到 " << bytes_read << " 字节数据\n";
        // 处理数据并返回结果...
    }
}

int main() {
    io_context io;
    ip::tcp::socket sock1(io);
    ip::tcp::socket sock2(io);

    // 假设已完成两个socket的连接逻辑...

    // 启动两个协程
    spawn(io, [&](yield_context yield) { handle_socket_read(sock1, yield); });
    spawn(io, [&](yield_context yield) { handle_socket_read(sock2, yield); });

    io.run(); // 单线程调度所有协程
    return 0;
}

在单核心CPU受限的场景下，多线程是反优化——线程切换的开销会吃掉本来就紧张的CPU资源。而用非阻塞IO+事件循环，或者C++20协程，只用一个线程就能高效处理多个并行IO任务，最大化CPU利用率，同时避免不必要的上下文切换。

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