罗罗编程学习记录 全栈面试题库
本页导航 展开查看

14.8 阶段 7 服务端与基础组件

所属:全栈开发面试题库 / 学习路径 / 14 C++ 与系统开发

本页目录

一、阶段定位

本阶段是 C++ 服务端开发的综合应用——把前六个阶段的知识组装成一个能跑的服务端组件。核心是:事件循环(阶段 5 epoll 的封装)、RPC 协议(Protobuf + 自定义编码)、存储引擎(LSM-tree 概念)、协程(C++20 coroutines)。学完这一阶段,你能独立写一个高性能 RPC 服务或 KV 存储的原型。

不掌握本阶段会在后面具体卡在哪:

  • 写了一个多线程 accept 服务,连接数上不去——你不知道事件循环应该是单线程 + epoll,而不是每连接一线程。
  • 想用 Protobuf 做 RPC 序列化,但不会写 .proto 文件,也不知道 Protobuf 与 gRPC 的关系。
  • 听说 RocksDB 是 LSM-tree 引擎,但不知道为什么用 LSM 而不是 B+ 树。
  • 看到 C++20 coroutine 的 co_await、co_return 完全看不懂,不知道它和 async/await 是不是一回事。

判断自己卡住的标志:(1) 让你画出一个 RPC 请求从 socket 到业务逻辑再返回的完整链路,你只能说"收数据、处理、发数据";(2) 给你一段 muduo 或 boost.asio 代码,你看不懂事件循环怎么组织;(3) 你不知道 Protobuf 怎么定义消息、怎么序列化。出现任一现象,先把本阶段六个模块过一遍再进 阶段 8 领域延伸(可选)。

二、阶段目标与投入

能力目标(可验证的行为) 验证方式
能基于 epoll 写一个简单事件循环(reactor 模式) 单线程处理多连接 echo
能定义 Protobuf 消息并做序列化/反序列化 .proto 编译后在 C++ 中使用
能说明 RPC 框架的核心组件(编解码、路由、线程池、超时) 画出 RPC 链路图
能说明 LSM-tree 与 B+ 树的区别与适用场景 给场景选存储引擎
能写一个 C++20 协程的基本示例(生成器或 awaitable) 编译通过,理解 co_await
能说明 muduo / boost.asio / Folly 各自的定位与选型 给场景选网络库

建议学时:

  • 全职(每天 4–6 小时):3–4 周,约 60–70 小时。其中事件循环 16 小时、Protobuf 与 RPC 16 小时、存储引擎 12 小时、协程 12 小时、网络库选型 6 小时、实战 8 小时。
  • 在职(每天 2 小时、周末补 4 小时):6–8 周,约 70 小时。

学时分配:事件循环 25%、RPC 与 Protobuf 25%、存储引擎 15%、协程 15%、网络库 10%、实战 10%。

三、先修自检

先修项 合格标准 不合格时怎么办
阶段 5 系统编程 懂 socket、epoll、信号 回到 阶段 5
阶段 4 并发 懂 thread、mutex、atomic 回到 阶段 4
阶段 6 工程化 懂 CMake、CI、perf 回到 阶段 6
数据结构 懂 B+ 树、哈希表、队列 补数据结构基础

四、知识地图

模块 知识点 掌握程度 对应题库章节
事件循环 Reactor 模式、event loop、定时器、线程池模型 能讲清原理 09.1 高并发基础
Protobuf .proto 语法、编译、序列化、编码原理 会用 06.14 API 协议专题
RPC 框架 编解码、服务路由、超时、重试、连接池 了解 06.14 API 协议专题
存储引擎 LSM-tree、SSTable、WAL、memtable、compaction 了解 05.1 关系型数据库通用能力
C++20 协程 co_await、co_return、co_yield、awaitable、promise_type 了解 04.9.3 多线程与原子操作
网络库 muduo、boost.asio、libevent、libuv、Folly 了解 09.1 高并发基础

五、分模块精讲

5.1 Reactor 事件循环

为什么需要它:阶段 5 已经写了 epoll 事件循环,但那是裸的。真实服务需要定时器、线程池、连接管理、读写缓冲——这就是 Reactor 模式。

核心机制:

  • Reactor 模式:一个事件循环(epoll_wait)+ 事件分发器 + 事件处理器。
  • 单 Reactor 单线程:所有连接在一个线程里处理,简单但 CPU 密集任务会阻塞。
  • 单 Reactor 多线程:事件循环在主线程,业务逻辑丢到线程池;IO 不阻塞。
  • 多 Reactor:主 Reactor 负责 accept,子 Reactor 负责读写;Nginx、Redis 用这种模型。
  • 定时器:用最小堆或时间轮管理超时事件,epoll_wait 超时时间取最近定时器。

最小可运行示例:

// 伪代码:Reactor 事件循环骨架
class EventLoop {
    int epfd_;
    std::map<int, std::function<void()>> read_cb_;
public:
    void add(int fd, std::function<void()> cb) {
        epoll_event ev{.events=EPOLLIN, .data.fd=fd};
        epoll_ctl(epfd_, EPOLL_CTL_ADD, fd, &ev);
        read_cb_[fd] = std::move(cb);
    }
    void run() {
        epoll_event events[128];
        while (running_) {
            int n = epoll_wait(epfd_, events, 128, 1000);
            for (int i = 0; i < n; ++i) {
                int fd = events[i].data.fd;
                read_cb_[fd]();          // 分发到回调
            }
        }
    }
};

常见坑:

现象 原因 修法
事件循环卡住 业务逻辑在事件循环线程里做了重计算 业务丢线程池
定时器不准 epoll_wait 超时没考虑最近定时器 计算最近超时时间

5.2 Protobuf 与 RPC 序列化

为什么需要它:网络传输需要结构化数据。JSON 可读性好但慢且大;Protobuf 是二进制序列化,快、小、跨语言。

核心机制:

  • .proto 文件定义消息结构:message User { string name = 1; int32 age = 2; }。
  • 编号 1、2 是字段 tag,不是值;新增字段加新编号,不影响旧版本。
  • protoc --cpp_out=. user.proto 编译成 .pb.h 与 .pb.cc。
  • 序列化:msg.SerializeToString(&data);反序列化:msg.ParseFromString(data)。
  • RPC 框架:gRPC 基于 Protobuf,定义 service 与 rpc 方法,自动生成桩代码。
  • 选型:内部服务用 gRPC;边缘场景考虑 brpc、thrift。

最小可运行示例:

// user.proto
syntax = "proto3";
message User {
    string name = 1;
    int32 age = 2;
}
message GetUserRequest {
    string user_id = 1;
}
message GetUserResponse {
    User user = 1;
}
// 编译:protoc --cpp_out=. user.proto
#include "user.pb.h"
#include <iostream>
int main() {
    User u;
    u.set_name("ann");
    u.set_age(30);
    std::string data;
    u.SerializeToString(&data);
    User parsed;
    parsed.ParseFromString(data);
    std::cout << parsed.name() << " " << parsed.age() << "\n";
    return 0;
}

常见坑:

现象 原因 修法
Protobuf 链接失败 没链接 protobuf 库 CMake find_package(Protobuf)
字段改了编号 旧数据反序列化错乱 编号永不重用

5.3 RPC 框架核心组件

为什么需要它:有了序列化,还需要把请求从 socket 读到、路由到具体方法、调用、把响应写回——这就是 RPC 框架。

核心机制:

  • 编解码:读消息 → 解析 header(长度、方法名、request_id)→ 解析 body(Protobuf)。
  • 服务路由:根据方法名找到对应的 Service 方法。
  • 线程池:IO 线程收请求,业务线程池处理;避免 IO 线程阻塞。
  • 超时与重试:客户端设超时,失败后重试(幂等接口)。
  • 连接池:复用 TCP 连接,避免每次建连。
  • 链路追踪:每个请求带 trace_id,跨服务传递。

5.4 存储引擎基础:LSM-tree

为什么需要它:KV 存储(RocksDB、LevelDB、Cassandra)用 LSM-tree 而不是 B+ 树,因为写多读少的场景 LSM 快得多。

核心机制:

  • LSM-tree(Log-Structured Merge-tree):
    • 写:先写 WAL(预写日志),再写 memtable(内存跳表);memtable 满了刷成 SSTable(磁盘有序文件)。
    • 读:先查 memtable,再查磁盘上的 SSTable;用 bloom filter 快速判断 key 是否在 SSTable 中。
    • compaction:后台合并多个 SSTable,清理冗余与删除标记。
  • B+ 树:读快写慢,随机写需要磁盘寻道;适合读多写少。
  • LSM-tree:写顺序 IO,快;读需要查多个 SSTable,慢;写多读少场景。
  • RocksDB:Facebook 基于 LevelDB 优化,支持多列族、压缩、备份。

常见坑:

现象 原因 修法
写吞吐低 WAL 刷盘太慢 调 sync 策略或 group commit
读延迟高 SSTable 太多 调 compaction 频率
compaction 影响线上 后台 IO 抢占 限速 compaction

5.5 C++20 协程入门

为什么需要它:C++20 coroutines 让你用同步写法写异步代码——co_await 不阻塞线程,等 IO 完成时线程去做别的事。这是阶段 7 最前沿的部分。

核心机制:

  • 三个关键字:co_await(等待异步操作)、co_return(返回并结束)、co_yield(生成值并暂停)。
  • 协程函数返回类型必须是一个 promise(如 std::future、自定义 task)。
  • 与 async/await 类比:概念类似,但 C++ 协程更底层,需要自己实现 promise_type。
  • 应用:异步 IO 服务(不阻塞线程等 socket)、生成器(range 按需生成)。
  • 状态:C++20 协程是标准库级,具体框架(asio、Folly)仍在演进,生产用 Folly 或 asio 扩展。

最小可运行示例:

#include <coroutine>
#include <iostream>

struct Generator {
    struct promise_type {
        int current_value;
        Generator get_return_object() { return Generator{}; }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always yield_value(int v) { current_value = v; return {}; }
        void return_void() {}
        void unhandled_exception() { std::terminate(); }
    };
    using handle = std::coroutine_handle<promise_type>;
    handle h_;
    explicit Generator(handle h) : h_(h) {}
    ~Generator() { if (h_) h_.destroy(); }
    int next() { h_.resume(); return h_.promise().current_value; }
};

Generator counter() {
    for (int i = 0; i < 3; ++i) {
        co_yield i;          // 生成 i 并暂停
    }
}

int main() {
    auto g = counter();
    for (int i = 0; i < 3; ++i) {
        std::cout << g.next() << "\n";   // 0 1 2
    }
    return 0;
}

常见坑:

现象 原因 修法
协程编译报错 返回类型不是协程类型 用自定义 Generator 或 asio task
co_await 后线程不继续 awaiter 没 resume 实现 awaiter 时确保完成后 resume

5.6 网络库选型

为什么需要它:不要自己从零写网络库。成熟的网络库经过多年生产验证,直接用。

核心机制:

  • muduo:陈硕写的 C++11 多线程 Reactor 网络库,国内教学与面试常用,代码简洁。
  • boost.asio:Boost 库的跨平台网络库,支持协程,生态成熟。
  • libevent:C 写的事件库,memcached、Chrome 用。
  • libuv:Node.js 的事件库,跨平台。
  • Folly:Facebook 的基础库,含协程、无锁队列、高性能容器,生产用。
  • brpc:百度的 RPC 框架,支持多协议、多线程。

选型经验:学习用 muduo;跨平台用 asio;高性能生产用 Folly + brpc。

六、分层练习

6.1 复现型

练习 要求 验收标准 预计耗时
Reactor echo 基于 epoll 写 Reactor 事件循环 单线程处理 100 连接 4 小时
Protobuf 序列化 定义 User 消息,序列化反序列化 数据一致 1 小时
RPC 链路图 画出 RPC 请求从 socket 到业务的完整链路 含编解码、路由、线程池 1 小时
协程生成器 写一个 counter 协程 输出 0 1 2 2 小时
LSM 概念 画 LSM-tree 写读流程 含 WAL、memtable、SSTable、compaction 1 小时

6.2 改造型

练习 要求 验收标准 预计耗时
加定时器 给 Reactor 加超时关闭空闲连接 空闲连接 60 秒后断开 2 小时
加线程池 业务逻辑丢线程池,IO 线程不阻塞 压测时 IO 线程不卡 3 小时
Protobuf 加字段 给 User 加 email 字段,旧数据反序列化不崩 兼容旧数据 1 小时
对比 muduo/asio 跑两个 echo 性能对比 数据表格 2 小时

6.3 设计型

练习 要求 验收标准 预计耗时
设计一个 KV 服务 基于 Reactor + Protobuf 实现 Set/Get 客户端可读写 6 小时
设计一个 RPC 框架 含编解码、路由、线程池、超时 能调用远程方法 8 小时
整理网络库选型表 muduo/asio/libevent/Folly/brpc 对比 表格可作为选型参考 2 小时

七、排障表

现象 可能原因 排查步骤 解决办法
事件循环卡住 业务逻辑在 IO 线程做重计算 perf 看热点 业务丢线程池
Protobuf 反序列化错乱 字段编号改了或类型不对 看 proto 定义 编号永不重用
RPC 超时 业务慢或线程池满 看线程池队列 调线程池大小或优化业务
写吞吐低 WAL 同步慢 看磁盘 IO 调 sync 策略
读延迟高 SSTable 太多 看 compaction 状态 调 compaction 频率
协程编译失败 返回类型不对 看编译器报错 用正确协程类型
连接数上不去 单线程 Reactor CPU 瓶颈 perf 看 CPU 多 Reactor 或线程池
compaction 影响线上 后台 IO 抢占 iostat 看磁盘 限速 compaction

八、出口条件

全部勾选后进入 阶段 8 领域延伸(可选)。

  • [ ] 能基于 epoll 写一个简单 Reactor 事件循环
  • [ ] 能定义 Protobuf 消息并做序列化/反序列化
  • [ ] 能说明 RPC 框架的核心组件与请求链路
  • [ ] 能说明 LSM-tree 与 B+ 树的区别与适用场景
  • [ ] 能写一个 C++20 协程生成器示例
  • [ ] 能说明 muduo/boost.asio/Folly 的定位与选型
  • [ ] 能独立设计一个 KV 服务或 RPC 框架原型

自测题:

  1. Reactor 模式的核心思想?单 Reactor 与多 Reactor 的区别?
    • 要点:事件分发器 + 事件处理器;单 Reactor 一个线程处理所有连接,多 Reactor 主从分离。
  2. Protobuf 为什么用数字编号而不是字段名?
    • 要点:数字编号小、快;新增字段加新编号保持向后兼容。
  3. LSM-tree 为什么比 B+ 树写快?
    • 要点:LSM 写顺序 IO(WAL + memtable),B+ 树随机写需要磁盘寻道。
  4. C++20 协程的 co_await 与阻塞函数调用的区别?
    • 要点:co_await 不阻塞线程,等 IO 完成时线程去做别的事;阻塞调用会卡住线程。
  5. RPC 框架的核心组件有哪些?
    • 要点:编解码、服务路由、线程池、超时、重试、连接池、链路追踪。
  6. muduo 与 boost.asio 各自适合什么场景?
    • 要点:muduo 学习与中小项目;asio 跨平台生产,支持协程。