欢迎光临
我们一直在努力

基于boost库C++网络编程(五):基于asio的多线程池和协程调度

AsioIOServicePool(多 io_context + 多线程)

设计目的

解决「单 io_context + 单线程」的性能瓶颈:Asio 的 io_context.run() 是单线程事件循环,所有 IO 事件(读写、连接)都串行处理,高并发下会出现 IO 阻塞。IOServicePool 创造多个独立的 io_context,每个 io_context 绑定一个线程,让不同客户端的 IO 事件在不同线程并行处理,最大化利用多核 CPU,提升服务器并发能力。

核心原理

核心机制作用
多 io_context 每个 io_context 管理一部分客户端连接的 IO 事件,相互独立
线程绑定 每个 io_context 对应一个线程,线程执行 io_context.run() 处理该 io_context 的事件
轮询分配 通过 GetIOService() 轮询返回不同的 io_context,均衡各 io_context 的负载
work 对象 阻止 io_context.run() 因「无待处理事件」退出,保证线程持续运行
优雅停止 销毁 work 对象 → 让 io_context.run() 退出 → join 线程,避免资源泄漏

// 核心成员:多个io_context + 每个io_context的work + 对应线程 + 轮询索引
std::vector<IOService> _ioServices; // 存储多个io_context
std::vector<WorkPtr> _works; // 每个io_context绑定一个work,防止run()退出
std::vector<std::thread> _threads; // 每个io_context对应一个线程
std::size_t _nextIOService; // 轮询分配的索引

// 构造函数:创建io_context、work、线程
AsioIOServicePool::AsioIOServicePool(std::size_t size):_ioServices(size), _works(size), _nextIOService(0) {
// 1. 为每个io_context创建work对象
for (std::size_t i = 0; i < size; ++i) {
_works[i] = std::unique_ptr<Work>(new Work(_ioServices[i]));
}
// 2. 每个线程运行对应io_context的run(),处理该io_context的IO事件
for (std::size_t i = 0; i < size; ++i) {
_threads.push_back(std::thread([this, i]() {
_ioServices[i].run(); // 线程阻塞在run(),处理IO事件
}));
}
}

// 轮询分配io_context:新连接会拿到不同的io_context,均衡负载
boost::asio::io_context& AsioIOServicePool::GetIOService() {
auto& service = _ioServices[_nextIOService++];
if (_nextIOService >= _ioServices.size()) {
_nextIOService = 0; // 轮询重置
}
return service;
}

// 停止线程池:销毁work → 让run()退出 → join线程
void AsioIOServicePool::Stop() {
for (auto& work : _works) {
work.reset(); // 销毁work,io_context.run()失去"虚拟任务",会退出
}
for (auto& thread : _threads) {
thread.join(); // 等待线程结束,避免僵尸线程
}
}

关键要点

  • 优势:不同连接的 IO 事件完全隔离,无线程安全问题(每个连接绑定一个 io_context,对应一个线程);
  • 缺点:io_context 数量固定(默认 CPU 核心数),连接数远超 io_context 时,单个 io_context 下的连接仍串行处理;
  • 适用场景:中高并发场景,连接数适中,追求 IO 隔离性。

AsioIOThreadPool(单 io_context + 多线程 + Strand)

设计目的

优化 IOServicePool 的缺点:IOServicePool 是「多 io_context + 多线程」,而 IOThreadPool 是「单 io_context + 多线程」—— 让单个 io_context 的事件循环在多个线程中并发执行,进一步提升并发;同时解决「同一个 socket 回调在多线程并发执行」的线程安全问题。

核心原理

1. 单 io_context + 多线程的核心逻辑
  • 只创建一个 io_context,启动多个线程同时调用 io_context.run();
  • Asio 会自动将就绪的 IO 事件分发给不同线程执行回调,实现 IO 事件的并行处理;
  • 相比 IOServicePool,无需维护多个 io_context,资源占用更少。
2. 核心隐患 & Strand 解决方案
隐患原因Strand 解决思路
同一个 socket 的回调(如 Read/Write)可能在不同线程并发执行,导致数据竞争(比如同时读 socket 缓冲区) 单 io_context 多线程运行时,回调会被分发到不同线程 Strand 是 Asio 的「

// 1. IOThreadPool:单io_context + 多线程
class AsioThreadPool:public Singleton<AsioThreadPool> {
private:
boost::asio::io_context _service; // 唯一的io_context
std::unique_ptr<asio::io_context::work> _work; // 防止run()退出
std::vector<std::thread> _threads; // 多个线程跑同一个io_context.run()
};

AsioThreadPool::AsioThreadPool(int threadNum):_work(new asio::io_context::work(_service)) {
// 多个线程运行同一个io_context的run()
for (int i = 0; i < threadNum; i++) {
_threads.emplace_back([this]() {
_service.run(); // 多个线程并发执行run(),处理IO事件
});
}
}

// 2. Strand 解决线程安全:CSession中添加Strand成员
class CSession {
private:
strand<io_context::executor_type> _strand; // 串行执行器
};

// 构造函数初始化Strand(绑定当前io_context的执行器)
CSession:CSession(asio::io_context& io_context, CServer* server):
_socket(io_context), _strand(io_context.get_executor()) { … }

// 所有IO回调绑定到Strand,保证串行执行
void CSession::Start() {
_socket.async_read_some(asio::buffer(_data, MAX_LENGTH),
// 绑定Strand:即使io_context在多线程运行,该回调也串行执行
asio::bind_executor(_strand,
std::bind(&CSession::HandleRead, this, …)));
}

关键要点

  • Strand 本质:不是锁,而是「任务队列」—— 所有绑定到 Strand 的回调会被放入队列,由 Asio 保证串行执行,性能比 mutex 更高;
  • 对比 IOServicePool:
    • IOServicePool:多 io_context 隔离,无线程安全问题,但资源占用高;
    • IOThreadPool:单 io_context 多线程,用 Strand 解决线程安全,资源占用低,并发更高;
  • 适用场景:高并发场景,连接数远超 CPU 核心数,追求极致并发。

Asio 协程调度

设计目的

解决传统 Asio 异步编程的「回调地狱」:传统异步编程依赖嵌套回调(比如 Read→处理→Write→处理→Read…),代码逻辑碎片化,可读性、可维护性极差。Asio 协程(基于 C++20 Coroutine 或 Boost.Coroutine)将异步操作转为同步写法,逻辑线性化,代码简洁易懂。

核心原理

协程核心概念作用
asio::awaitable 协程的返回类型,表示「可挂起的异步操作」
co_await 挂起当前协程,直到异步操作完成(比如 co_await socket.async_read_some),底层仍是非阻塞 IO
asio::co_spawn 启动协程,detached 表示协程后台运行,不阻塞当前线程
this_coro::executor 获取当前协程绑定的执行器(io_context)

// 1. 简单的Echo协程:同步写法实现异步读写
asio::awaitable<void> echo(asio::ip::tcp::socket socket) {
try {
char data[1024];
for (;;) {
// co_await挂起协程,直到read完成,返回读取的字节数
std::size_t n = std::get<1>(co_await socket.async_read_some(asio::buffer(data), asio::use_awaitable));
// 同样,co_await挂起直到write完成
co_await async_write(socket, asio::buffer(data, n), asio::use_awaitable);
}
}catch (std::exception &e) { … }
}

// 2. 监听协程:接受连接并启动echo协程
asio::awaitable<void> listener() {
auto executor = co_await asio::this_coro::executor; // 获取当前执行器
asio::ip::tcp::acceptor acceptor(executor,{asio::ip::tcp::v4(), 10086});
for (;;){
asio::ip::tcp::socket socket(executor);
co_await acceptor.async_accept(socket,asio::use_awaitable); // 挂起直到接受连接
// 启动echo协程,detached表示后台运行
asio::co_spawn(executor, echo(std::move(socket)),asio::detached);
}
}

// 3. 改进服务器:CSession用协程替代回调
void CSession::Start() {
auto shared_this = std::shared_from_this();
// 启动协程,处理当前连接的读写
asio::co_spawn(_io_context, [=]()->asio::awaitable<void> {
try {
while (!_b_close) {
// 同步写法读取头部(替代async_read + 回调)
_recv_head_node->Clear();
std::size_t n = std::get<1>(co_await asio::async_read(_socket, asio::buffer(_recv_head_node->data, HEAD_TOTAL_LEN), asio::use_awaitable));
// 解析头部、读取包体、投递逻辑队列… 线性逻辑,无需回调
LogicSystem::GetInstance()->PostMsgToQue(…);
}
} catch (std::exception &e) { … }
}, asio::detached);
}

关键要点

  • 协程优势:逻辑线性化,无回调嵌套,调试更简单(可以单步调试 co_await 后的代码);
  • 底层本质:协程是「用户态轻量级线程」,co_await 挂起时不会阻塞线程,底层仍是 Asio 的异步 IO,性能和传统回调一致;
  • 适用场景:所有异步场景,尤其是逻辑复杂的业务(如多次读写、数据解析)。

Asio 实现 HTTP 服务器(客户端示例)

设计目的

HTTP 是基于 TCP 的应用层协议,Asio 作为底层网络库,可直接实现 HTTP 协议解析 —— 核心是按 HTTP 报文格式(固定结构)解析请求 / 响应,理解「流式协议 + 应用层格式」的处理方式。

核心原理

1. HTTP 报文固定格式
  • HTTP 请求(以 GET 为例):

    plaintext

    GET /path HTTP/1.1\\r\\n
    Host: 127.0.0.1:8080\\r\\n
    Accept: */*\\r\\n
    Connection: close\\r\\n
    \\r\\n // 空行分隔头部和体

  • HTTP 响应:

    plaintext

    HTTP/1.1 200 OK\\r\\n // 状态行
    Content-Type: text/html\\r\\n // 响应头部
    Content-Length: 1024\\r\\n
    \\r\\n // 空行
    <html>…</html> // 响应体

2. Asio 处理 HTTP 的核心机制
机制作用
asio::streambuf 流式缓冲区,适合处理「分段读取的文本协议」(HTTP 是文本协议)
async_read_until 按分隔符读取(如 \\r\\n 读状态行,\\r\\n\\r\\n 读头部),精准解析分段数据
async_read 读取剩余的响应体,直到 EOF(连接关闭)

// 1. 客户端构造函数:构造HTTP GET请求,启动地址解析
client::client(asio::io_context& io_context, const std::string& server, const std::string& path):resolver(io_context), socket(io_context){
// 构造HTTP请求(固定格式)
std::ostream request_stream(&request);
request_stream << "GET " << path << " HTTP/1.1\\r\\n";
request_stream << "Host: " << server << "\\r\\n";
request_stream << "Accept: */*\\r\\n";
request_stream << "Connection: close\\r\\n\\r\\n"; // 空行结束头部

// 解析服务器地址(ip:port),启动异步解析
resolver.async_resolve(ip, port, boost::bind(&client::handle_resolve, this, …));
}

// 2. 回调链:解析地址→连接→发送请求→解析响应
// 解析响应状态行(HTTP/1.1 200 OK)
void client::handle_read_status_line(const boost::system::error_code& err) {
if (!err) {
std::istream response_stream(&response);
std::string http_version;
unsigned int status_code;
response_stream >> http_version >> status_code; // 解析版本和状态码
if (status_code != 200) { … } // 检查状态码
// 继续读取响应头部(直到\\r\\n\\r\\n)
asio::async_read_until(socket, response, "\\r\\n\\r\\n", boost::bind(&client::handle_read_headers, this, …));
}
}

// 解析响应头部,然后读取响应体
void client::handle_read_headers(const boost::system::error_code& err) {
if (!err) {
std::istream response_stream(&response);
std::string header;
// 读取所有头部(直到空行)
while (std::getline(response_stream, header) && header != "\\r\\n") {
std::cout << header << std::endl;
}
// 读取响应体(直到EOF)
asio::async_read(socket, response,asio::transfer_at_least(1), boost::bind(&client::handle_read_content, this, …));
}
}

关键要点

  • HTTP 处理核心:按「状态行→头部→空行→体」的顺序分段读取,利用 async_read_until 精准匹配分隔符;
  • streambuf 优势:自动管理缓冲区,无需手动处理「粘包 / 拆包」(Asio 会自动拼接分段数据);
  • 扩展:实现 HTTP 服务器只需反向逻辑 —— 监听端口→接受连接→读取 HTTP 请求→解析请求→构造响应→发送响应。

整体总结

模块核心解决问题核心方案适用场景
IOServicePool 单 io_context 串行瓶颈 多 io_context + 多线程 中高并发,追求 IO 隔离
IOThreadPool 多 io_context 资源浪费 单 io_context + 多线程 + Strand 高并发,追求极致性能
协程调度 回调地狱 协程 + co_await 线性化逻辑 所有异步场景,简化代码
HTTP 实现 应用层协议解析 按 HTTP 格式分段读取 + streambuf HTTP 客户端 / 服务器开发

核心设计思想

  • 并发优化:从「单线程」→「多 io_context 多线程」→「单 io_context 多线程 + Strand」,逐步提升并发,同时解决线程安全;
  • 代码简化:协程将异步回调转为同步写法,平衡「高性能」和「可维护性」;
  • 协议落地:底层网络库(Asio)+ 应用层协议格式(HTTP),体现「分层设计」思想(网络层→应用层)。
  • 赞(0)
    未经允许不得转载:171主机测评 » 基于boost库C++网络编程(五):基于asio的多线程池和协程调度
    分享到: 更多 (0)

    评论 抢沙发

    • 昵称 (必填)
    • 邮箱 (必填)
    • 网址