Rust AI CLI 的网络层优化:连接池、HTTP/2 和请求合并的关键技术
一、连接池:别再每次都重新握手了
最开始我的代码长这样——每次请求都创建一个新的 reqwest::Client:
// ❌ 每次请求都新建 Client,每次都要做 TLS 握手
async fn call_api_naive(prompt: &str) -> Result<String, reqwest::Error> {
// 创建一个全新的 HTTP 客户端 —— 这会导致每次请求都重新建立连接
let client = reqwest::Client::new();
let resp = client
.post("https://api.openai.com/v1/chat/completions")
.json(&build_body(prompt))
.send()
.await?;
Ok(resp.text().await?)
}
这么写的问题很明显:每次调用都要完整地走一遍 TCP 三次握手 + TLS 四次握手,光握手就要几十毫秒。如果你的 CLI 工具需要连续发多个请求(比如先做代码分析,再做代码生成),这个延迟就叠加起来了。
正确的做法是用连接池复用连接。reqwest 的 Client 本身就是带连接池的,关键是全局只创建一个实例:
use once_cell::sync::Lazy;
use reqwest::Client;
// ✅ 全局单例 Client,内部维护连接池,复用 TCP 连接
static HTTP_CLIENT: Lazy<Client> = Lazy::new(|| {
Client::builder()
// 连接池中最大空闲连接数(每个 host)
.pool_max_idle_per_host(20)
// 空闲连接的最长存活时间(秒)
.pool_idle_timeout(Some(Duration::from_secs(90)))
// HTTP/2 默认开启,这里显式确认
.http2_prior_knowledge()
.build()
.expect("Failed to build HTTP client")
});
async fn call_api_optimized(prompt: &str) -> Result<String, reqwest::Error> {
// 复用全局 Client,底层自动从连接池获取连接
let resp = HTTP_CLIENT
.post("https://api.openai.com/v1/chat/completions")
.json(&build_body(prompt))
.send()
.await?;
Ok(resp.text().await?)
}
这里有几个关键参数:
pool_max_idle_per_host(20):每个目标 host 最多保留 20 个空闲连接。如果并发量大,可以适当调高。pool_idle_timeout:空闲连接超过 90 秒就关闭,避免占用服务端资源。http2_prior_knowledge():强制使用 HTTP/2,下一节详细讲。
二、HTTP/2 多路复用:一个连接跑多路请求
HTTP/1.1 虽然支持 Keep-Alive,但请求是串行的——同一个连接上,上一个请求没完成,下一个就得等着(队头阻塞)。HTTP/2 通过多路复用解决了这个问题:
在 Rust 里启用 HTTP/2 很简单,reqwest 默认就会优先尝试 HTTP/2(通过 ALPN 协商)。如果想强制使用:
let client = Client::builder()
.http2_prior_knowledge() // 跳过 HTTP/1.1 协商,直接用 HTTP/2
.build()
.unwrap();
但要注意:http2_prior_knowledge() 只有在确认服务器支持 HTTP/2 的情况下才使用,否则连接会失败。更稳妥的方式是不加这一行,让客户端和服务端自动协商。
三、请求合并:相同问题别重复发
在 AI CLI 场景里,有时候用户会连续问类似的问题(比如"这段代码还有问题吗"紧接着"能再详细解释下吗"),或者我们的工具内部需要并发查询多个 AI 接口。这时候请求合并就很有用。
思路是:用一个请求队列,把短时间内(比如 50ms 内)对同一个 endpoint 的请求合并成一次批量调用:
use std::collections::HashMap;
use tokio::sync::Mutex;
use std::time::{Duration, Instant};
/// 请求合并器:将短时间内的多个请求合并为一次批量调用
struct RequestBatcher<T: Clone> {
// 待合并的请求缓冲区:key → (内容, 回调发送端, 过期时间)
buffer: Mutex<HashMap<String, (T, tokio::sync::oneshot::Sender<String>, Instant)>>,
// 合并窗口:多长时间内的请求会被合并
batch_window: Duration,
}
impl<T: Clone + std::fmt::Debug> RequestBatcher<T> {
fn new(batch_window: Duration) -> Self {
Self {
buffer: Mutex::new(HashMap::new()),
batch_window,
}
}
/// 将请求加入合并队列,返回一个接收响应的 channel
async fn submit(&self, key: String, payload: T) -> String {
let (tx, rx) = tokio::sync::oneshot::channel();
let mut buffer = self.buffer.lock().await;
buffer.insert(key, (payload, tx, Instant::now()));
drop(buffer); // 释放锁
// 等待批量处理的结果
rx.await.unwrap_or_else(|_| "请求合并失败".to_string())
}
}
// 后台任务:定时检查缓冲区,批量处理过期或满额的请求
async fn batch_processor<T: Clone + std::fmt::Debug>(batcher: std::sync::Arc<RequestBatcher<T>>) {
let mut interval = tokio::time::interval(Duration::from_millis(50));
loop {
interval.tick().await;
let mut buffer = batcher.buffer.lock().await;
let now = Instant::now();
// 收集所有到期的请求
let expired: Vec<String> = buffer
.iter()
.filter(|(_, (_, _, deadline))| now.duration_since(*deadline) >= batcher.batch_window)
.map(|(k, _)| k.clone())
.collect();
for key in expired {
if let Some((payload, tx, _)) = buffer.remove(&key) {
// 模拟批量处理的 API 调用
let result = format!("处理完成: {:?}", payload);
let _ = tx.send(result); // 发送结果给等待者
}
}
}
}
核心思想就是:用 oneshot channel 让多个调用者等待同一个批量结果,后台定时器每隔 50ms 把积压的请求一起处理掉。
四、实战:一个优化前后的完整对比
我把上面三个优化整合进了一个简单的 AI CLI 工具里,对比优化前后的性能:
use std::time::Instant;
use reqwest::Client;
use once_cell::sync::Lazy;
// 全局 HTTP 客户端(连接池 + HTTP/2)
static CLIENT: Lazy<Client> = Lazy::new(|| {
Client::builder()
.pool_max_idle_per_host(10)
.pool_idle_timeout(Some(Duration::from_secs(60)))
.build()
.unwrap()
});
async fn optimized_call(prompt: &str) -> String {
// 1. 复用连接池(一次握手,多次请求)
// 2. HTTP/2 自动多路复用
let start = Instant::now();
let resp = CLIENT
.post("https://api.example.com/v1/chat")
.json(&serde_json::json!({"prompt": prompt}))
.send()
.await
.unwrap();
let text = resp.text().await.unwrap();
let elapsed = start.elapsed();
println!("请求耗时: {}ms", elapsed.as_millis());
text
}
// 对比:连续发 5 个请求
async fn benchmark() {
let prompts = vec![
"分析这段代码的复杂度",
"给出优化建议",
"生成单元测试",
"检查安全问题",
"写注释文档",
];
// 并发发送 5 个请求 —— 得益于 HTTP/2 和连接池,速度远超串行
let start = Instant::now();
let tasks: Vec<_> = prompts
.iter()
.map(|p| optimized_call(p))
.collect();
let results = futures::future::join_all(tasks).await;
println!("5 个请求总耗时: {}ms", start.elapsed().as_millis());
}
实测下来,5 个串行请求在优化前要大约 3-4 秒(每次都要 TLS 握手),优化后用连接池 + HTTP/2 多路复用,总耗时降到 600-800ms,基本等于最慢的那个请求的时间。
实际项目里我还观察到一个更隐蔽的现象:连接池的 pool_max_idle_per_host 设太大(比如 50),在调用多个不同的 API 域名时,TCP 连接总数超过了 Linux 的 net.ipv4.ip_local_port_range 上限,触发"无法分配本地端口"的奇怪错误。排查了半天才发现不是 Rust 代码的问题,而是内核参数。后续把 pool_max_idle_per_host 调到 5,并监控 TIME_WAIT 连接数,问题消失。
五、总结
- 连接池——全局一个
Client,别每次都new,让底层自动管理 TCP 连接。 - HTTP/2 多路复用——一个连接上并行发多个请求,避免 HTTP/1.1 的队头阻塞。
- 请求合并——用 channel 和定时器把短时间内的重复请求合并成一次批量调用。
这些优化说起来都不复杂,但真正落地到自己写的工具里,体验提升是实打实的。作为一个转行的程序员,我的学习方式就是遇到问题 → 查文档 → 写 demo → 做对比实验,把每个点都吃透。网络层优化还有很多东西要学(QUIC、零拷贝、自定义 DNS 解析等),慢慢来吧。
567



被折叠的 条评论
为什么被折叠?



