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 解决方案
| 同一个 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 客户端 / 服务器开发 |


![P11246 [GESP202409 六级] 小杨和整数拆分-171主机测评](https://www.171host.com/wp-content/uploads/2026/11/20261108100631-6af049a75855c-220x150.png)


