基于协程的高并发服务器
面试考点
C++20 协程为高并发网络服务器提供了新的编程模型。面试官通过这道题考察你是否理解协程相比线程/回调的优势、事件循环与协程的配合方式、以及如何用 co_await 把异步 I/O 写成同步风格的代码。
核心概念
传统高并发方案有两种:多线程(一个连接一个线程,简单但开销大)和事件驱动回调(一个线程处理多个连接,高效但代码复杂)。协程结合了两者的优点:代码写起来像同步的(容易理解),但底层是异步的(高效)。每个连接对应一个协程,协程在等待 I/O 时挂起,事件循环在 I/O 就绪后恢复协程。
架构概览
客户端1 ──┐
客户端2 ──┤ ┌── 协程1(处理连接1)
客户端3 ──┼──→ [事件循环] ──┼── 协程2(处理连接2)
... │ (epoll) ├── 协程3(处理连接3)
客户端N ──┘ └── 协程N(处理连接N)
每个协程在 co_await 处挂起,让出 CPU 给其他协程
事件循环在 I/O 就绪时恢复对应的协程
一个线程可以处理数万个并发连接基本示例
#include <iostream>
#include <coroutine>
#include <vector>
#include <queue>
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
#include <cstring>
// ============================
// Task 协程类型
// ============================
// 通用协程任务类型
struct Task {
struct promise_type {
Task get_return_object() {
return Task{
std::coroutine_handle<promise_type>::from_promise(*this)
};
}
std::suspend_never initial_suspend() { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
void return_void() {}
void unhandled_exception() {
exception_ = std::current_exception();
}
std::exception_ptr exception_;
};
std::coroutine_handle<promise_type> handle;
Task(std::coroutine_handle<promise_type> h) : handle(h) {}
~Task() {
if (handle) handle.destroy();
}
// 禁止拷贝
Task(const Task&) = delete;
Task& operator=(const Task&) = delete;
// 允许移动
Task(Task&& other) noexcept : handle(other.handle) {
other.handle = nullptr;
}
Task& operator=(Task&& other) noexcept {
if (handle) handle.destroy();
handle = other.handle;
other.handle = nullptr;
return *this;
}
};
// ============================
// 模拟事件循环
// ============================
// 简化的事件循环:管理协程的挂起和恢复
class EventLoop {
public:
// 注册一个协程等待某个 fd 的可读事件
void register_read(int fd, std::coroutine_handle<> handle) {
read_waiters_[fd] = handle;
}
// 注册一个协程等待某个 fd 的可写事件
void register_write(int fd, std::coroutine_handle<> handle) {
write_waiters_[fd] = handle;
}
// 添加就绪的协程到执行队列
void schedule(std::coroutine_handle<> handle) {
ready_queue_.push(handle);
}
// 模拟事件通知:fd 可读
void notify_readable(int fd) {
auto it = read_waiters_.find(fd);
if (it != read_waiters_.end()) {
ready_queue_.push(it->second);
read_waiters_.erase(it);
}
}
// 运行事件循环
void run() {
while (!ready_queue_.empty()) {
auto handle = ready_queue_.front();
ready_queue_.pop();
if (!handle.done()) {
handle.resume();
}
}
}
static EventLoop& instance() {
static EventLoop loop;
return loop;
}
private:
std::queue<std::coroutine_handle<>> ready_queue_;
std::unordered_map<int, std::coroutine_handle<>> read_waiters_;
std::unordered_map<int, std::coroutine_handle<>> write_waiters_;
};
// ============================
// Awaitable:异步读取
// ============================
// 模拟异步读取操作
struct AsyncRead {
int fd;
char* buffer;
size_t size;
ssize_t bytes_read = 0;
AsyncRead(int fd, char* buf, size_t sz)
: fd(fd), buffer(buf), size(sz) {}
bool await_ready() const noexcept {
// 检查数据是否已经就绪
// 真实实现中会检查 socket 缓冲区
return false; // 假设总是需要等待
}
void await_suspend(std::coroutine_handle<> handle) {
// 向事件循环注册:当 fd 可读时恢复此协程
EventLoop::instance().register_read(fd, handle);
// 真实实现中:epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &event)
}
ssize_t await_resume() {
// 协程被恢复时,数据已经就绪
// 真实实现中:bytes_read = read(fd, buffer, size)
// 这里模拟读取
const char* msg = "Hello from client";
bytes_read = std::min(size, strlen(msg));
std::memcpy(buffer, msg, bytes_read);
return bytes_read;
}
};
// 模拟异步写入操作
struct AsyncWrite {
int fd;
const char* data;
size_t size;
AsyncWrite(int fd, const char* d, size_t sz)
: fd(fd), data(d), size(sz) {}
bool await_ready() const noexcept { return false; }
void await_suspend(std::coroutine_handle<> handle) {
EventLoop::instance().register_write(fd, handle);
}
ssize_t await_resume() {
// 真实实现中:return write(fd, data, size)
std::cout << " [fd=" << fd << "] 发送 " << size << " 字节" << std::endl;
return static_cast<ssize_t>(size);
}
};
// 模拟异步接受连接
struct AsyncAccept {
int listen_fd;
AsyncAccept(int fd) : listen_fd(fd) {}
bool await_ready() const noexcept { return false; }
void await_suspend(std::coroutine_handle<> handle) {
EventLoop::instance().register_read(listen_fd, handle);
}
int await_resume() {
// 真实实现中:return accept(listen_fd, nullptr, nullptr)
static int next_fd = 100;
int client_fd = next_fd++;
std::cout << " 接受新连接: fd=" << client_fd << std::endl;
return client_fd;
}
};
// ============================
// 协程风格的连接处理
// ============================
// 处理单个客户端连接(协程)
Task handle_client(int client_fd) {
std::cout << " [fd=" << client_fd << "] 开始处理" << std::endl;
char buffer[1024];
// co_await 读取数据——协程在此挂起,直到数据就绪
ssize_t n = co_await AsyncRead(client_fd, buffer, sizeof(buffer));
if (n > 0) {
std::cout << " [fd=" << client_fd << "] 收到 "
<< n << " 字节" << std::endl;
// 处理请求(业务逻辑)
std::string response = "HTTP/1.1 200 OK\r\n\r\nHello";
// co_await 写回响应——协程在此挂起,直到可写
co_await AsyncWrite(client_fd, response.data(), response.size());
}
std::cout << " [fd=" << client_fd << "] 处理完毕" << std::endl;
}
// 服务器主循环(协程)
Task server_loop(int listen_fd) {
std::cout << "服务器启动,监听 fd=" << listen_fd << std::endl;
for (int i = 0; i < 3; i++) { // 演示接受 3 个连接
// co_await 等待新连接——协程在此挂起
int client_fd = co_await AsyncAccept(listen_fd);
// 为每个连接启动一个新协程
// 不创建新线程,只是创建一个协程帧
handle_client(client_fd);
}
std::cout << "服务器停止接受连接" << std::endl;
}
// ============================
// 对比:三种并发模型
// ============================
/*
模型1:多线程(一连接一线程)
void handle_client_threaded(int fd) {
char buf[1024];
read(fd, buf, sizeof(buf)); // 阻塞
// 处理请求...
write(fd, response, len); // 阻塞
close(fd);
}
void server_threaded(int listen_fd) {
while (true) {
int client_fd = accept(listen_fd, ...); // 阻塞
std::thread(handle_client_threaded, client_fd).detach();
// 每个连接一个线程
// 10000 个连接 = 10000 个线程
// 每个线程 ~8MB 栈空间
// 上下文切换开销大
}
}
模型2:事件驱动回调
void on_read(int fd) {
char buf[1024];
read(fd, buf, sizeof(buf));
// 处理请求...
register_write(fd, on_write);
// 回调地狱:逻辑分散在多个回调函数中
}
void on_write(int fd) {
write(fd, response, len);
close(fd);
}
void on_accept(int listen_fd) {
int client_fd = accept(listen_fd, ...);
register_read(client_fd, on_read);
// 状态需要手动在回调之间传递
}
void event_loop() {
while (true) {
auto events = epoll_wait(epfd, ...);
for (auto& ev : events) {
ev.callback(ev.fd);
}
}
}
模型3:协程(本文档的方案)
Task handle_client_coro(int fd) {
char buf[1024];
co_await async_read(fd, buf, sizeof(buf)); // 看起来同步
// 处理请求...
co_await async_write(fd, response, len); // 看起来同步
close(fd);
// 代码像同步的,但底层是异步的
// 一个线程处理数万个连接
// 协程帧 ~100 字节(vs 线程 ~8MB)
}
*/
// ============================
// 演示
// ============================
void demo() {
auto& loop = EventLoop::instance();
// 启动服务器协程
auto server = server_loop(42);
// 模拟事件到达
std::cout << "\n--- 模拟:连接1到达 ---" << std::endl;
loop.notify_readable(42); // 监听 fd 可读 = 新连接到达
loop.run();
std::cout << "\n--- 模拟:连接1数据到达 ---" << std::endl;
loop.notify_readable(100); // 客户端 fd 可读
loop.run();
// 模拟写就绪
std::cout << "\n--- 模拟:连接1可写 ---" << std::endl;
auto& write_waiters = loop; // 简化处理
// 在真实实现中,epoll 会通知可写事件
// 这里直接通知
loop.notify_readable(42); // 第二个连接
loop.run();
}
int main() {
std::cout << "=== 基于协程的高并发服务器 ===" << std::endl;
demo();
return 0;
}三种并发模型对比
| 特性 | 多线程 | 事件驱动回调 | 协程 |
|---|---|---|---|
| 代码风格 | 同步(直观) | 异步(回调分散) | 同步风格(直观) |
| 内存开销 | ~8MB/连接(栈) | 极低 | ~100B/连接(协程帧) |
| 上下文切换 | 内核态切换(~μs) | 无 | 用户态切换(~ns) |
| 万级并发 | 困难(线程爆炸) | 容易 | 容易 |
| 调试难度 | 中等 | 高(回调地狱) | 低 |
| 错误处理 | try/catch | 回调传递错误码 | try/catch(自然) |
| CPU 利用率 | 中(线程切换开销) | 高 | 高 |
协程服务器的关键组件
| 组件 | 职责 | 实现方式 |
|---|---|---|
| 事件循环 | 监听 I/O 事件 | epoll (Linux) / IOCP (Windows) / kqueue (macOS) |
| Awaitable | 封装异步操作 | 实现 await_ready/suspend/resume |
| Task | 协程返回类型 | promise_type + coroutine_handle |
| 调度器 | 管理协程恢复 | 就绪队列 + 事件通知 |
| 连接管理 | 跟踪活跃连接 | fd → 协程句柄映射 |
常见问题
协程帧分配在堆上,会不会有性能问题?
每个协程帧通常只有几十到几百字节(存储局部变量和挂起点),比线程栈小几个数量级。编译器可以做 HALO 优化(Heap Allocation eLision Optimization),在某些情况下完全消除堆分配。实际测量中,协程的开销远小于线程创建/切换的开销。
一个线程能处理多少个协程?
理论上没有硬限制,主要受内存限制。如果每个协程帧 256 字节,1GB 内存可以容纳约 400 万个协程。实际应用中,单线程处理数万到数十万个并发连接是常见的。
协程服务器需要多少个线程?
通常是每个 CPU 核心一个线程,每个线程运行自己的事件循环和协程调度器。这样既利用了多核,又避免了线程间的锁竞争。连接通过某种策略(如 SO_REUSEPORT 或 round-robin)分配到各个线程。
适用场景
- 高并发 Web 服务器(HTTP/HTTPS)
- 即时通讯服务器(WebSocket)
- 代理服务器和网关
- 数据库连接池前端
注意事项
- C++20 只提供协程的底层机制,不提供事件循环和网络库
- 生产环境建议使用成熟框架(如 Boost.Asio + 协程、Corosio)
- 协程中不要执行阻塞操作(会阻塞整个事件循环)
- CPU 密集型任务应该分发到独立的线程池
- 协程的异常传播需要在 promise_type 中正确处理
总结
基于协程的高并发服务器结合了多线程和事件驱动的优点:代码像同步写法一样直观,但底层是异步的、高效的。核心架构是事件循环 + 协程:每个连接一个协程(几百字节),co_await 在 I/O 等待时挂起协程,事件循环在 I/O 就绪时恢复协程。面试中要能对比三种并发模型的优缺点,解释 co_await 如何与 epoll 配合工作,以及说明协程帧比线程栈小几个数量级的内存优势。