基于协程的高并发服务器 ​

面试考点 ​

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 就绪时恢复对应的协程
一个线程可以处理数万个并发连接

基本示例 ​

cpp
#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 配合工作,以及说明协程帧比线程栈小几个数量级的内存优势。