Rust / 系统课时
加入背压与资源限制
加入背压与资源限制
并发 TCP 服务不能只追求“尽快接收”:连接、待处理请求和下游调用如果都无限增长,过载最终会变成内存膨胀、超时扩散甚至进程崩溃。本课把三处容量显式设为有界,并分别定义等待、拒绝和降级行为。
学习目标
- 使用
Semaphore限制同时存活的 TCP 连接和下游调用数。 - 使用有界
mpsc队列阻止请求在内存中无限堆积。 - 为连接满、队列满和下游变慢分别选择等待、拒绝或降级策略。
先把容量放在边界上
背压的核心不是“让所有请求都慢一点”,而是让生产速度超过处理能力时,压力停在可控边界。TCP 服务常见的三个边界是连接数、已接收但未处理的请求数,以及数据库、HTTP 等下游的并发调用数。

连接上限通常应在 accept 之后立刻判定,避免为已经过载的连接继续创建昂贵任务。请求队列必须使用有界 mpsc::channel(capacity);如果改成无界队列,只是把压力从 socket 搬到了堆内存。下游并发则适合用另一个 Semaphore 单独限制。
用有界队列和 Semaphore 承载压力
下面的最小服务把三种限制放到同一条处理链中。连接满时返回 BUSY;队列满时当前请求返回 QUEUE_FULL;进入队列的请求等待下游许可,若两秒仍拿不到业务结果,则向客户端返回 DEGRADED。
项目只需要 Tokio:
[package]
name = "bounded-tcp"
version = "0.1.0"
edition = "2021"
[dependencies]
tokio = { version = "1", features = ["full"] }将下面代码保存为 src/main.rs:
use std::{io, sync::Arc, time::Duration};
use tokio::{
io::{AsyncBufReadExt, AsyncWriteExt, BufReader},
net::{TcpListener, TcpStream},
sync::{
mpsc,
oneshot,
OwnedSemaphorePermit,
Semaphore,
TryAcquireError,
},
time,
};
struct Job {
line: String,
reply: oneshot::Sender<String>,
}
#[tokio::main]
async fn main() -> io::Result<()> {
let listener = TcpListener::bind("127.0.0.1:8080").await?;
let connections = Arc::new(Semaphore::new(64));
let downstream = Arc::new(Semaphore::new(8));
let (tx, rx) = mpsc::channel::<Job>(32);
tokio::spawn(dispatch(rx, downstream));
println!("listening on 127.0.0.1:8080");
loop {
let (mut stream, _) = listener.accept().await?;
// 连接层不等待:没有许可时立即拒绝,避免继续创建任务。
match connections.clone().try_acquire_owned() {
Ok(permit) => {
let tx = tx.clone();
tokio::spawn(async move {
if let Err(err) = handle_connection(stream, tx, permit).await {
eprintln!("connection error: {err}");
}
});
}
Err(TryAcquireError::NoPermits) => {
let _ = stream.write_all(b"BUSY\n").await;
let _ = stream.shutdown().await;
}
Err(TryAcquireError::Closed) => break,
}
}
Ok(())
}
async fn handle_connection(
stream: TcpStream,
tx: mpsc::Sender<Job>,
_permit: OwnedSemaphorePermit,
) -> io::Result<()> {
let (reader, mut writer) = stream.into_split();
let mut lines = BufReader::new(reader).lines();
while let Some(line) = lines.next_line().await? {
let (reply_tx, reply_rx) = oneshot::channel();
let job = Job { line, reply: reply_tx };
// 请求层不等待:队列已满时明确拒绝当前请求。
match tx.try_send(job) {
Ok(()) => {}
Err(mpsc::error::TrySendError::Full(_)) => {
writer.write_all(b"QUEUE_FULL\n").await?;
continue;
}
Err(mpsc::error::TrySendError::Closed(_)) => return Ok(()),
}
// 等待有上限:下游长期拥塞时返回降级结果。
match time::timeout(Duration::from_secs(2), reply_rx).await {
Ok(Ok(reply)) => writer.write_all(reply.as_bytes()).await?,
_ => writer.write_all(b"DEGRADED\n").await?,
}
}
Ok(())
}
async fn dispatch(mut rx: mpsc::Receiver<Job>, limit: Arc<Semaphore>) {
while let Some(job) = rx.recv().await {
let permit = match limit.clone().acquire_owned().await {
Ok(permit) => permit,
Err(_) => break,
};
tokio::spawn(async move {
let _permit = permit;
time::sleep(Duration::from_millis(100)).await;
let Job { line, reply } = job;
let _ = reply.send(format!("ok: {line}\n"));
});
}
}预期输出
listening on 127.0.0.1:8080服务会持续监听,因此启动日志后不会自动退出。实际端口可按部署配置调整;客户端正常发送一行文本时会收到 ok: <内容>,而过载状态分别返回 BUSY、QUEUE_FULL 或 DEGRADED。
为不同过载点选择策略
等待适合“短暂抖动且调用方愿意等”的位置,例如下游 Semaphore::acquire_owned().await。但等待本身也必须受队列容量和超时约束,否则等待者仍会无限累积。立即拒绝适合连接数或请求队列已经达到硬上限的情况,让调用方尽快重试或转移流量。
降级适合存在可接受替代结果的业务,例如返回缓存、简化响应或只读数据。示例用 DEGRADED 作为明确占位,真实服务应把它替换成协议允许的降级响应,并记录连接占用、队列长度、许可等待时间和拒绝次数。还要注意,示例里的响应超时只停止当前连接等待,并不会自动取消已经入队的 Job;生产代码若下游工作昂贵,应让任务携带取消信号,避免客户端已放弃后仍继续消耗资源。
容量值不应凭感觉取大。先根据文件描述符、单连接内存、下游连接池和允许延迟给出安全上限,再用压测观察拒绝率与尾延迟。好的背压设计会在资源耗尽之前主动变慢或拒绝,而不是等到进程失去响应后才失败。