Asio库通过io_context实现异步非阻塞IO，核心组件包括io_context、socket和async_*函数；示例展示异步TCP服务器使用shared_from_this管理生命周期，以回调处理读写，io_context.run()驱动事件循环，客户端同理需调用run()；关键点为保持io_context运行、正确管理对象生命周期、避免回调抛异常，可多线程调用run()提升性能，适用于高并发网络服务。

在C++中使用Asio库进行异步网络编程，可以高效实现非阻塞IO模型，适用于高并发的网络服务开发。Asio（Asynchronous Input/Output）是一个跨平台的C++库，用于网络和低层IO编程，它支持同步和异步操作，而异步模式正是实现高性能服务器的核心。

理解Asio中的异步模型

Asio通过事件循环（io_context）来管理异步操作。所有异步任务都注册到io_context中，当某个IO事件就绪（如数据到达、连接完成），对应的回调函数会被调用。

异步操作不会阻塞调用线程，程序可以在等待IO期间执行其他任务，这正是非阻塞IO的关键所在。

核心组件包括：

立即学习“C++免费学习笔记（深入）”；

Browser Session Manager

使用 Playwright 为 jimeng.jianying.com 管理浏览器会话，导入 cookies/localStorage 以自动化视频生成工作流，支持图片上传等功能

下载

• io_context：事件循环，负责调度和执行异步操作
• socket：代表网络连接，如tcp::socket
• async_* 系列函数：发起异步操作，如 async_read, async_write, async_accept
• 回调函数（handler）：操作完成时被调用，处理结果

编写一个异步TCP服务器示例

以下是一个简单的异步回显服务器，展示如何使用Asio进行非阻塞编程：

#include <asio.hpp>
#include <memory>
#include <iostream>

using asio::ip::tcp;

class session : public std::enable_shared_from_this<session>
{
public:
    session(tcp::socket socket) : socket_(std::move(socket)) {}

    void start()
    {
        do_read();
    }

private:
    void do_read()
    {
        auto self(shared_from_this());
        socket_.async_read_some(asio::buffer(data_),
            [this, self](std::error_code ec, std::size_t length)
            {
                if (!ec)
                    do_write(length);
            });
    }

    void do_write(std::size_t length)
    {
        auto self(shared_from_this());
        asio::async_write(socket_, asio::buffer(data_, length),
            [this, self](std::error_code ec, std::size_t /*length*/)
            {
                if (!ec)
                    do_read(); // 继续读取
            });
    }

    tcp::socket socket_;
    char data_[1024];
};

class server
{
public:
    server(asio::io_context& io_context, short port)
        : acceptor_(io_context, tcp::endpoint(tcp::v4(), port))
    {
        do_accept();
    }

private:
    void do_accept()
    {
        acceptor_.async_accept(
            [this](std::error_code ec, tcp::socket socket)
            {
                if (!ec)
                {
                    std::make_shared<session>(std::move(socket))->start();
                }
                do_accept(); // 接受下一个连接
            });
    }

    tcp::acceptor acceptor_;
};

int main()
{
    try
    {
        asio::io_context io_context;
        server s(io_context, 8080);
        io_context.run(); // 启动事件循环
    }
    catch (std::exception& e)
    {
        std::cerr << "Exception: " << e.what() << "\n";
    }
    return 0;
}

这个例子展示了Asio异步编程的基本结构：

• 使用 shared_from_this 管理会话生命周期，避免对象提前析构
• 每个异步操作传入 lambda 作为回调，处理完成后的逻辑
• 通过递归调用 do_read 和 do_accept 实现持续服务
• io_context.run() 阻塞并运行事件循环，直到无任务为止

异步客户端的简单实现

客户端同样可以使用异步方式连接和通信：

void start_client()
{
    asio::io_context io_context;
    tcp::socket socket(io_context);

    socket.async_connect(tcp::endpoint(asio::ip::address::from_string("127.0.0.1"), 8080),
        [&socket](std::error_code ec)
        {
            if (!ec)
            {
                std::string msg = "Hello\n";
                asio::async_write(socket, asio::buffer(msg),
                    [](std::error_code ec, std::size_t length)
                    {
                        // 发送完成
                    });
            }
        });

    io_context.run();
}

注意：客户端也需要调用 io_context.run() 来驱动异步操作。

关键注意事项

使用Asio进行异步编程时，有几个要点必须掌握：

• 确保 io_context 在异步操作期间持续运行，否则回调不会被执行
• 正确管理对象生命周期，特别是使用 shared_ptr 配合 shared_from_this
• 避免在回调中抛出异常，应通过 error_code 处理错误
• 可使用多个线程调用 io_context::run() 提升性能
• 对于定时任务，可使用 asio::steady_timer 实现异步延时操作

基本上就这些。Asio的异步模型虽然初看复杂，但一旦理解了事件循环和回调机制，就能写出高效稳定的网络程序。非阻塞IO的优势在于能用少量线程处理大量连接，适合现代高并发场景。