C++ Web 框架性能实测:Hical vs Drogon vs Crow vs Oat++ vs cpp-httplib vs Cinatra(2026)

上一篇横评我们从架构设计、功能完整度和开发体验角度对比了四个 C++ Web 框架。结论是"各有适合的场景"——但没回答一个关键问题:到底差多少。本文用硬数据补上这个缺口:相同硬件、相同容器、相同压测工具,12 个场景全量对比,包括别人不太敢贴的对自己不利的数据。


目录


1. 引言

C++ Web 框架的选型讨论中,最常听到三句话:

  1. “Drogon 在 TechEmpower 上排名很高”
  2. “Crow 极简,几行代码就能跑”
  3. “Oat++ 零依赖,开箱即用”
  4. “cpp-httplib 零依赖单头文件,几行就能搭 HTTP 服务”
  5. “Cinatra 是国产 C++20 协程框架,性能号称顶尖”

这些都是事实,但缺少在统一条件下的定量对比。框架官网的 benchmark 通常只跑 Hello World,且各自用不同的硬件、不同的压测工具、不同的并发参数——数据之间几乎没有可比性。

本文的定位:

  • 补充 07 号文章 的定性对比,用数据量化各框架的性能差异
  • 与 11 号文章 的跨语言对比形成互补——那篇回答"C++ 和 Go/Rust 差多少",本篇回答"C++ 框架之间差多少"
  • 所有数据可复现——Docker 一键启动,run_bench.sh 跑一遍就能拿到结果

先说一件必须交代的事:本文数据采集于 2026-09-28,整份重跑过一轮。跟上一版逐格对了一遍,基础场景里各家偏移在 -3%+10%,高并发场景到了 +8%+32%。这个漂移量说明上一轮整体不该用,所以这版把 6 个框架 6 个场景全部重采了一遍,上一版的数字本文不再引用。


2. 测试环境与方法论

2.1 硬件 & 容器环境

项目规格
宿主机Windows 10 Enterprise LTSC 2021,Intel Core i7-11700K @ 3.60GHz(8 核 16 线程),32GB 内存
虚拟机Oracle VirtualBox 7.1,Ubuntu 24.04.3 LTS Server,8 CPU / 16GB 内存 / 102GB SSD
DockerDocker Engine 29.4.3(VM 内原生运行,非 Docker Desktop)
容器资源每容器限制 4 CPU + 1024MB 内存,nofile=65536
网络Docker 内部 bridge 网桥,wrk 独立容器通过服务名访问各框架

虚拟化配置说明:这台 VM 之前一直跑在宿主 Hyper-V / VBS 开启的状态下。VT-x 被 Hyper-V 独占后,VirtualBox 只能降级到 WHPX/NEM 慢路径——每次 VM exit 要走用户态 API、内存变成嵌套两级地址翻译、中断还得经 hypervisor 转发。对一个每秒百万次 syscall、百万次中断的网络密集负载来说,这个代价接近一个数量级。后来做了以下修正:

  1. 宿主机关闭 Hyper-V / VBS(bcdedit /set hypervisorlaunchtype off 后重启)
  2. 网卡从默认的 e1000(Intel 82540EM,全模拟网卡)换成 virtio-net(半虚拟化)
  3. 半虚拟化接口设为 KVM,启用 PAE/NX
  4. SATA 控制器勾选「使用主机 I/O 缓存」,虚拟硬盘标记为固态驱动器

修完前后不是小修小补,是 4 倍量级的差距。如果你也在 VirtualBox 里跑压测,建议先按上面四条自查一遍,再怀疑代码。

2.2 框架版本 & 编译配置

框架版本编译器优化级别异步模型备注
Hicalmain @ ba28ad0(2.7.0 后)GCC 14(Ubuntu 24.04)ReleaseBoost.Asio 协程仓库源码 + Boost 静态链接
Drogonv1.9.8GCC(Ubuntu 24.04 默认)ReleaseTrantor 事件循环
Crowv1.2.0GCC(Ubuntu 24.04 默认)ReleaseStandalone Asio单头文件
Oat++v1.3.0GCC(Ubuntu 24.04 默认)ReleaseSimple(同步线程池)零外部依赖
cpp-httplibv0.18.3GCC(Ubuntu 24.04 默认)Release同步线程池单头文件 + nlohmann/json
Cinatrayalantinglibs v0.3.0GCC(Ubuntu 24.04 默认)ReleaseC++20 协程阿里 yalantinglibs 生态

所有框架统一 -DCMAKE_BUILD_TYPE=Release(CMake 的 Release 默认就是 -O3 -DNDEBUG,没有工程级覆盖),统一 4 工作线程。Oat++ 用 Simple API(同步模型),每个连接占用一个线程上下文——这是 Oat++ 官方推荐的标准模式。

2.3 压测工具与参数

工具版本默认参数
wrk4.1.04 threads, 100 connections, 30s duration

POST 请求使用挂载的 Lua 脚本(post_echo.lua)携带 JSON Body {"name":"Alice","age":30,"email":"alice@example.com"},避免 heredoc 管道问题。

宿主机内核参数在容器启动前调过:端口范围放宽到 1024-65535、somaxconn 和 tcp_max_syn_backlog 提到 65535、打开 tcp_tw_reuse。这些是网络栈级别的参数,容器创建时从宿主 net namespace 继承。

2.4 数据采集流程

  1. 每个场景用 wrk -t4 -c<并发> -d30s 打一轮,逐个框架串行执行,同一时刻只有一个框架在承压
  2. 原始 wrk 输出和 QPS 汇总都在 benchmark/output/results.md 里,本文所有表格都从这份文件里取数
  3. 补充数据(内存 / 二进制 / 镜像大小 / 代码行数)由 collect_stats.sh 采集,结果在 benchmark/output/stats.md

2.5 测试场景总览

#场景端点目标
1Hello WorldGET /框架调度纯开销下限
2JSON 序列化GET /api/statusJSON 构建 + 序列化性能
3JSON EchoPOST /api/echo反序列化 + 序列化完整链路
4路径参数GET /users/42参数路由匹配 + JSON 响应
5高并发 1,000GET /中等并发扩展性
6高并发 10,000GET /极限并发,观察错误率和 OOM

中间件场景不进横评。 之前测过 0/3/10 层协程洋葱链和一整套同步过滤链,但比到后面发现问题在于"不可比":六家里只有 Hical 和 Drogon 有真正等价的运行时协程中间件,其余四家(Crow / Oat++ / cpp-httplib / Cinatra)要么是编译期模板、要么根本没有运行时中间件机制,只能用 std::function 手搓调用链去模拟。拿模拟出来的数字和真机制并排比,看着热闹,其实测的不是同一个东西。

所以中间件从这张表里撤掉了。Hical 的 bench 服务器里仍留着 /middleware/0 和 /middleware/10 两个端点——那是给我自己跟踪中间件开销用的(见仓库里 VM 压测指南的基线表),不进框架对比,其他五家的服务器里也没有对应实现。


3. 基础吞吐量对比

3.1 Hello World — 纯框架开销

六个框架返回相同的 13 字节固定字符串,不涉及 JSON 或数据库。

Hical

1
2
3
4
server.router().get("/",
    [](const HttpRequest&) -> HttpResponse {
        return HttpResponse::ok("Hello, World!");
    });

Drogon

1
2
3
4
5
6
app().registerHandler("/",
    [](const HttpRequestPtr&, std::function<void(const HttpResponsePtr&)>&& callback) {
        auto resp = HttpResponse::newHttpResponse();
        resp->setBody("Hello, World!");
        callback(resp);
    }, {Get});

Crow

1
2
CROW_ROUTE(app, "/")
([]() { return crow::response(200, "Hello, World!"); });

Oat++

1
2
3
ENDPOINT("GET", "/", hello) {
    return createResponse(Status::CODE_200, "Hello, World!");
}

cpp-httplib

1
2
3
4
svr.Get("/",
    [](const httplib::Request&, httplib::Response& res) {
        res.set_content("Hello, World!", "text/plain");
    });

Cinatra

1
2
3
4
server.set_http_handler<GET>("/",
    [](coro_http_request& req, coro_http_response& res) {
        res.set_status_and_content(status_type::ok, "Hello, World!");
    });
框架QPSAvg 延迟Max 延迟Stdev
Cinatra605,123149.52us12.22ms183.62us
Hical562,810174.11us19.66ms315.23us
Drogon515,760195.54us16.08ms265.15us
Crow311,188327.38us19.55ms255.88us
Oat++226,0902.92ms100.31ms7.22ms
cpp-httplib85,41027.56ms317.88ms36.14ms

分析:Cinatra(605K)第一,Hical(563K)第二,两家差 7.5%;Drogon(516K)第三,跟 Hical 差 9.1%。这仨加起来跨了 17% 的区间,但量级还是一档。再往下 Crow(311K)和 Oat++(226K)各差一档,cpp-httplib 的 85K 是最后一名。

这里必须说清楚一个口径问题:六个框架返回的都是 13 字节的 Hello, World!,实际在网络上传的字节数却差得很多。用 Transfer/sec ÷ Requests/sec 反推每请求的 wire 字节(wrk 的 MB 是 1024 进制):

框架每请求字节其中响应头Transfer/sec
Hical175 B~162 B93.93MB
Drogon151 B~138 B74.27MB
Crow134 B~121 B39.77MB
cpp-httplib110 B~97 B8.95MB
Cinatra106 B~93 B61.17MB
Oat++97 B~84 B20.91MB

这个算法可以拿 wrk 日志里的 GB read 交叉验证:Hical 那行写着 16940788 requests in 30.10s, 2.76GB read,2.76 GiB ÷ 16940788 ≈ 174.9 B,跟表里的 175 B 对得上。

Hical 每请求比 Cinatra 多推约 69 字节,整轮多发 65% 的字节。差异主要在响应头的自动附带策略上——Hical 在连接建立时预构建了 Server / Connection / Date 三个通用头,Cinatra 默认不发 Date。

所以「Cinatra 比 Hical 快 7.5%」这句话得打个折扣:论单位带宽的效率,Hical 反而更高(93.93MB/s vs 61.17MB/s)。反过来说,如果你的瓶颈是出网带宽而不是 QPS,这 69 字节就是实打实的成本。QPS 是单维指标,读表的时候心里得有这根弦。

3.2 JSON 序列化

各框架构建相同结构的 JSON 对象({"status":"running","framework":"xxx"})并序列化为响应体。

JSON 库差异:

框架JSON 库序列化方式
HicalBoost.JSONjson::object → json::value
DrogonjsoncppJson::Value → 内部序列化
Crowcrow::jsoncrow::json::wvalue
Oat++内置 ObjectMapperDTO → 自动序列化
cpp-httplibnlohmann/jsonjson → dump()
Cinatraiguana (struct_json)iguana::to_json()
框架QPSAvg 延迟Max 延迟StdevQPS 下降
Cinatra567,065166.70us10.01ms214.82us-6.3%
Hical534,547183.22us10.30ms213.57us-5.0%
Drogon361,592285.04us12.26ms244.45us-29.9%
Crow280,068362.79us9.32ms222.95us-10.0%
Oat++190,9153.27ms83.43ms7.46ms-15.6%
cpp-httplib79,62529.93ms550.67ms40.90ms-6.8%

“QPS 下降"列表示相对 Hello World 场景的衰减,反映 JSON 序列化引入的额外开销。

分析:这个场景基本是 JSON 库的选型考试。Hical 的 Boost.JSON(-5.0%)、Cinatra 的 iguana(-6.3%)、cpp-httplib 的 nlohmann(-6.8%)三个几乎没付出代价,Drogon 的 jsoncpp 掉了 29.9%。差距不是框架的锅,是库的锅——换个 JSON 库,Drogon 这个数字能立刻好看一截。

3.3 JSON Echo(反序列化 + 序列化)

接收 POST Body,解析后原样返回。

框架QPSAvg 延迟Max 延迟StdevQPS 下降
Cinatra533,886178.81us9.07ms187.74us-11.8%
Hical439,399234.31us13.15ms236.15us-21.9%
Drogon292,815349.84us10.56ms239.38us-43.2%
Crow236,927428.62us9.31ms211.02us-23.9%
Oat++146,8883.65ms152.02ms7.54ms-35.0%
cpp-httplib72,80232.51ms541.59ms44.04ms-14.8%

Drogon 在 JSON Echo 场景相对 Hello World 下降 43.2%,比纯序列化场景(-29.9%)又多掉 13 个点——jsoncpp 的反序列化比序列化更贵。Hical 掉 21.9%,Cinatra 掉 11.8%。

3.4 路径参数

GET /users/42,路由系统从 URL 提取 id 参数并构建 JSON 响应。

路由匹配机制差异:

框架静态路由参数路由匹配复杂度
Hical哈希表 O(1)按方法分组线性扫描O(1) + O(N/M)
Drogon哈希表正则匹配O(1) + O(regex)
Crow前缀树 TrieTrie 节点匹配O(path_len)
Oat++PathPattern模式匹配O(pattern_count)
cpp-httplib正则匹配正则捕获组O(regex)
CinatraRadix Tree:param_name 模式O(path_len)
框架QPSAvg 延迟Max 延迟Stdev
Cinatra538,086181.31us11.01ms221.29us
Hical516,732192.86us10.45ms208.88us
Drogon335,876303.41us9.27ms200.81us
Crow271,959370.34us8.21ms164.05us
Oat++189,8582.79ms93.68ms6.24ms
cpp-httplib80,82028.99ms238.31ms38.21ms

参数路由这档 Cinatra(538K)和 Hical(517K)都在 50 万上下,正则匹配那套代价没怎么体现在 Hical 身上,只掉了 8.2%。Drogon(336K)掉到第二梯队,正则匹配参数路由的代价在这里体现得比较直接。

3.5 基础场景汇总

场景CinatraHicalDrogonCrowOat++cpp-httplib
Hello World605,123562,810515,760311,188226,09085,410
JSON 序列化567,065534,547361,592280,068190,91579,625
JSON Echo533,886439,399292,815236,927146,88872,802
路径参数538,086516,732335,876271,959189,85880,820

四个基础场景的名次一模一样:Cinatra 全第一,Hical 全第二,Drogon 全第三,后面 Crow、Oat++、cpp-httplib 依次排。Cinatra 对 Hical 的领先在 4.1%21.5% 之间浮动(路径参数最小、JSON Echo 最大);而 Drogon 一旦进 JSON 就掉到 -35%-43%——它不是被 Cinatra 甩开的,是被自己的 JSON 库甩开的。


4. 高并发扩展性

固定 Hello World 端点,逐步提升并发连接数(100 → 1000 → 10000),观察 QPS 变化和错误率。

4.1 QPS 随并发数变化

并发连接CinatraDrogonHicalCrowOat++cpp-httplib
100605,123515,760562,810311,188226,09085,410
1,000479,291464,828447,487265,762177,77184,332
10,000197,470197,957181,924185,720123,48074,864

相对 c=100 的衰减:

并发连接HicalDrogonCinatraCrowOat++cpp-httplib
1,000-20.5%-9.9%-20.8%-14.6%-21.4%-1.3%
10,000-67.7%-61.6%-67.4%-40.3%-45.4%-12.3%

4.2 延迟随并发数变化

并发连接CinatraDrogonHicalCrowOat++cpp-httplib
100149.52us195.54us174.11us327.38us2.92ms27.56ms
1,0002.05ms2.12ms2.24ms3.75ms7.86ms276.80ms
10,00035.09ms29.49ms31.56ms53.33ms54.73ms66.31ms

分析:从 100 并发到 1000 并发,Hical(-20.5%)和 Cinatra(-20.8%)一起掉两成,Crow 掉 14.6%,Drogon 只掉 9.9%。到 10000 并发,Drogon(198K)和 Cinatra(197K)咬在一起,Crow(186K)排第三,Hical(182K)第四——四个异步框架里它排最后。

这组和上一版是反过来的。 上一版 Hical 在 1000 并发排第二、10000 并发排第三,这一版两个档位各往后挪了一位。我的看法是上一版的整体测量就有偏差(见开头那段),但具体偏在哪、为什么偏,我没做 profiling,不编原因。

顺带记一笔我自己没想明白的地方:用 QPS × 平均延迟 反推在途请求数——Hical 98.0、Drogon 100.9、Crow 101.9、Cinatra 90.5,四家整整齐齐卡在 wrk 的 100 并发上,这个很合理。但 Oat++ 推出 660、cpp-httplib 推出 2354,两个数都超过了 100。按常理推不出这个结果,我没去查,先如实标在这里。

4.3 错误率 & Socket Errors

并发 10KHicalDrogonCrowCinatraOat++cpp-httplib
Socket errors无无无timeout 2,288timeout 7,899read 161,186 + timeout 55

说明:上一版 10K 测试里六个框架全都报 connect 8983 错误——容器有效 fd 只有一千出头,所谓的一万并发根本没压进去,测的其实是千级并发。这一版把 nofile 提到 65536、宿主内核参数也调了,连接是真建立起来了:Hical、Drogon、Crow 三家零错误,Cinatra 有 2288 个 timeout,Oat++ 的 7899 个 timeout 是同步线程池在万级连接下的典型表现。

cpp-httplib 出现了 16 万个读错误(read 161186),是六家里唯一报读方向错误的。同一场景它的 QPS 也掉到 74,864,六家最低。


5. 资源效率

5.1 内存占用

框架空载内存满载内存
Hical129.6MiB129.6MiB
Drogon97.79MiB92.05MiB
Cinatra92.46MiB86.87MiB
Crow65.02MiB64.91MiB
Oat++18.8MiB16.36MiB
cpp-httplib1.891MiB1.895MiB

数据来自 docker stats --no-stream,为容器级 RSS。满载数据在 wrk 同时压测所有框架时采样。

Hical 依旧是内存占用最高的,129.6MiB,比第二的 Drogon 高 33%——这是 PMR 三层内存池预分配换来的。Pool 预分配之后运行时几乎不再向系统要内存(空载满载一个数),代价就是启动就占住这一坨。cpp-httplib 的 1.9MiB 是另一个极端,因为它压根没有连接池和缓冲区池。

表里 Drogon、Cinatra、Oat++ 的满载数字比空载还低一点,这是 RSS 采样时刻的正常波动,不是真的把内存还回去了。Hical 和 cpp-httplib 空载满载完全一致,倒是很干净。

5.2 二进制 & Docker 镜像大小

框架二进制大小Docker 镜像备注
Hical3.0M122MB本地源码 + Boost 静态链接
Drogon1.9M122MBTrantor + jsoncpp 动态链接
Oat++767K118MB零外部依赖,全静态链接
Cinatra508K118MBHeader-only,yalantinglibs 生态
Crow401K118MBHeader-only,极少运行时依赖
cpp-httplib400K118MBHeader-only,零外部依赖

Hical 的 3.0M 是六家里最大的,因为它把 Boost.Asio / Boost.JSON / Boost.System 全都静态链进去了。Crow、cpp-httplib、Cinatra 框架本身是 header-only,外部依赖动态链接,二进制里只有用户代码和少量模板实例化。Docker 镜像的差异主要来自基础镜像(ubuntu:24.04 约 118MB),各框架额外增量只有 0~4MB——所以镜像大小这个指标基本没有区分度。

5.3 代码行数

框架文件行数
Crowcrow/main.cpp56
cpp-httplibcpphttplib/main.cpp65
Drogondrogon/main.cpp67
Cinatracinatra/main.cpp84
Hicalhical/main.cpp95
Oat++oatpp/main.cpp112

wc -l,含注释和空行,按横评用的端点集统计。Hical 那 95 行里有 36 行是 /middleware/0 和 /middleware/10 两个端点(只给 Hical 自己跟踪中间件开销用,其他五家没有对应实现),扣掉之后是 59 行,跟 Crow 的 56 行基本持平。剩下的差异基本只是 API 风格——Crow 的 CROW_ROUTE 一行一个端点最省,Oat++ 的 DTO + Controller 定义最啰嗦。这个数字看看就好,跟性能没关系。


6. 延迟分析

6.1 全场景延迟汇总(Avg / Max)

场景CinatraHicalDrogonCrowOat++cpp-httplib
Hello World149.52us / 12.22ms174.11us / 19.66ms195.54us / 16.08ms327.38us / 19.55ms2.92ms / 100.31ms27.56ms / 317.88ms
JSON 序列化166.70us / 10.01ms183.22us / 10.30ms285.04us / 12.26ms362.79us / 9.32ms3.27ms / 83.43ms29.93ms / 550.67ms
JSON Echo178.81us / 9.07ms234.31us / 13.15ms349.84us / 10.56ms428.62us / 9.31ms3.65ms / 152.02ms32.51ms / 541.59ms
路径参数181.31us / 11.01ms192.86us / 10.45ms303.41us / 9.27ms370.34us / 8.21ms2.79ms / 93.68ms28.99ms / 238.31ms
高并发 1K2.05ms / 238.93ms2.24ms / 152.87ms2.12ms / 166.47ms3.75ms / 16.43ms7.86ms / 1.67s276.80ms / 1.93s
高并发 10K35.09ms / 2.00s31.56ms / 83.39ms29.49ms / 94.41ms53.33ms / 76.53ms54.73ms / 2.00s66.31ms / 1.88s

6.2 延迟稳定性

Stdev 是比平均延迟更重要的指标——尾延迟才是生产环境里导致用户体验劣化的真正杀手。

场景CinatraHicalDrogonCrowOat++cpp-httplib
Hello World183.62us315.23us265.15us255.88us7.22ms36.14ms
高并发 1K3.25ms1.73ms1.26ms436.99us16.54ms370.58ms
高并发 10K21.43ms10.14ms10.00ms3.04ms95.18ms241.97ms

加粗为该项最低。

基础场景(100c)下四家异步框架的 Stdev 都挤在 180~320us 这一档:Cinatra 183.62us 最低,Crow 和 Drogon 差不太多(255.88us / 265.15us),Hical 的 315.23us 稍高一点。

Crow 的稳是全场最扎实的——1K 时 Stdev 436.99us、10K 时 3.04ms,两个档位都是最低。它 QPS 排在中游,但延迟这条线上没什么短板。

Hical 这一版的表现,跟上一版正好翻了个面。 上一版它在 10K 下的 Max 是 445.50ms,六家里最差;这一版是 83.39ms,只比 Crow 的 76.53ms 高一点,Stdev 10.14ms 同样只输给 Crow。1000 并发时 Max 152.87ms,也优于 Drogon 的 166.47ms 和 Cinatra 的 238.93ms。

Cinatra 反过来。10K 的平均延迟 35.09ms 看着还行,Max 直接 2.00s,Stdev 21.43ms 是四家异步框架里最高的,再加上那 2288 个 timeout。平均值这个指标把它的问题盖得严严实实。

选型的时候如果只扫 Avg 这一列,Cinatra 的 35ms 显得很稳妥,而上一版 Hical 那个 445ms 又显得很不稳妥——两次都看走眼了。


7. 综合分析与选型建议

7.1 维度评分

维度CinatraHicalDrogonCrowOat++cpp-httplib
基础 QPS★★★★★★★★★☆★★★★☆★★★☆☆★★☆☆☆★☆☆☆☆
高并发扩展性★★★★☆★★★☆☆★★★★★★★★★☆★★☆☆☆★☆☆☆☆
延迟稳定性★★☆☆☆★★★★☆★★★★☆★★★★★★☆☆☆☆★☆☆☆☆
内存效率★★★☆☆★★☆☆☆★★★☆☆★★★★☆★★★★★★★★★★
中间件灵活度★★☆☆☆★★★★★★★★★★★★☆☆☆★★☆☆☆★☆☆☆☆
代码简洁度★★★☆☆★★★☆☆★★★★☆★★★★★★★☆☆☆★★★★★
生态成熟度★★★☆☆★★☆☆☆★★★★★★★★☆☆★★★☆☆★★★★☆

中间件灵活度和生态成熟度基于架构分析和社区现状评估,非量化数据。所有维度按六框架内部横向比较,不是绝对水平。

7.2 各框架适用场景

选 Cinatra,如果:

  • 纯吞吐是首要指标(本文 6 个场景里它拿了 5 个第一)
  • 想用 C++20 协程 + 国产生态(yalantinglibs)
  • 需要 iguana 反射驱动的自动 JSON 序列化
  • 能接受高并发下明显的长尾(10K 时 Max 2 秒 + 2288 个 timeout),并且不介意中间件是全局 AOP 模型

选 Drogon,如果:

  • 高并发是核心场景(10K 连接下它是第一,198K QPS,且零错误)
  • 需要久经考验的生产级框架和完整生态(ORM、HTTP 客户端、WebSocket)
  • 能接受 jsoncpp 在 JSON 密集场景的开销,或打算换掉它

选 Hical,如果:

  • 需要路由级中间件精确控制(六家里只有 Hical 和 Drogon 支持,本文未压测中间件,此条为架构能力)
  • 对 JSON 序列化性能敏感(Boost.JSON 四个基础场景都在第二,紧跟 iguana)
  • 看重万级连接下的延迟波动和长尾(10K 时 Max 83.39ms、Stdev 10.14ms,两项都只输给 Crow)

选 Crow,如果:

  • 原型验证、内部工具、教学用途
  • 追求最小依赖和最快上手
  • 对延迟稳定性要求高于吞吐量(1K/10K 的 Stdev 都是全场最低)

选 Oat++,如果:

  • 零外部依赖是硬性需求
  • 喜欢 DTO + Controller 的强类型 API 风格
  • 高并发不是核心需求

选 cpp-httplib,如果:

  • 极致简洁,不想引入任何构建依赖
  • 原型验证、脚本式 HTTP 服务、嵌入式场景
  • 对性能要求不高,开发效率优先(记住它 10K 并发下会报 16 万个 read 错误)

7.3 性能格局总结

六框架性能依旧是 “四档” 格局,只是每一档的位置动了动:

  • 第一梯队:Cinatra(53万61万)和 Hical(44万56万)。Drogon 在纯文本场景与它们同档(52万),但一进 JSON 就掉到 29万~36万,卡在两档之间
  • 第二梯队(24万~31万 QPS):Crow 独占
  • 第三梯队(12万~23万 QPS):Oat++,同步线程池模型的天花板
  • 第四档(7万~8.5万 QPS):cpp-httplib

但第一梯队内部不是一个平面。Cinatra 赢在纯吞吐和高并发 1000;10K 要看 Drogon;要论万级连接下的长尾,是 Crow 和 Hical 的地盘。选型的时候先想清楚自己最怕什么——怕吞吐上不去,还是怕偶发长尾。


8. 结论

几点诚实的总结:

  1. Cinatra 这轮还是赢得很干净。6 个场景里 5 个第一,唯一输掉的是 10K 并发(197K vs Drogon 198K,差 0.2%)。Hical 在 6 个场景里全部落后 Cinatra,幅度 4.1%~21.5%。

  2. Cinatra 赢在基础吞吐,但高并发下压不住尾巴。10K 时 Max 2.00s、Stdev 21.43ms、2288 个 timeout,这三项在四家异步框架里都是最差的。平均延迟漂亮、尾巴失控,这类问题在"每天跑几亿请求"的场景里一定会暴露出来。

  3. Hical 这轮的表现在两张表上相反。QPS 侧两个并发档位都比上一版各退了一名;延迟侧它的长尾反而是六家里第二好的(10K 时 Max 83.39ms,上一版这个数是 445.50ms)。同样是"重测之后结论变了”,这次我没有 profiling 数据,不做归因,两组数都摆在这儿。

  4. 平均值和 Max 讲的是两个故事。四家异步框架的 Avg 延迟在 29.49ms~53.33ms 之间,最多差 1.8 倍;Max 从 Crow 的 76.53ms 到 Cinatra 的 2.00s,差了 26 倍。只看平均值那一列,看不出这中间到底发生了什么。

  5. JSON 库选型比框架选型影响更大。Drogon 换掉 jsoncpp,JSON 场景的数字能立刻好一截,而这是它四个基础场景里唯一明显掉队的地方。

  6. 微基准不等于生产性能。Hello World 和实际业务之间隔着数据库查询、鉴权、日志、复杂对象序列化等大量 I/O,框架的"裸 QPS"在生产里会被摊薄。

  7. 可复现比可信更重要。本文的全部测试环境和脚本都已开源,不同意结论?docker compose up 自己跑一遍。


9. 复现指南

所有测试代码、Docker 配置和压测脚本均已公开,详见仓库 benchmark/README.md,包含完整的构建、启动、压测、采集和清理流程。

1
2
3
git clone https://github.com/hical61/hical.git
cd hical/benchmark
# 后续步骤参照 benchmark/README.md

跑之前建议先自查虚拟化环境(见 2.1)。这台 VM 上开着 Hyper-V 和不开着,同一份二进制的成绩能差 4 倍——在那之前你测的是 hypervisor,不是框架。


利益声明:本文作者是 Hical 框架的开发者。为减少偏见,所有测试代码、Docker 配置和压测脚本均已公开,欢迎复现验证。对 Hical 不利的数据同样如实展示:6 个场景全部落后 Cinatra、10K 并发在四家异步框架里垫底、内存占用六家最高。