你的系统不会崩溃,它只是学会了慢慢死
大部分人第一次听说「背压」这个词,是在凌晨三点,队列堆积、接口超时、CPU 却只有百分之二十。监控上一片绿,告警一条没有,然后用户一个一个跑掉。你盯着屏幕心想:这不科学啊,资源明明还有很多。
不科学,是因为你把「资源没满」当成了「系统没问题」。可一个系统的健康,从来不是看 CPU 用了多少,而是看请求从入口到出口走得有多顺畅。堵在中间的东西,才是真正吃掉了你的钱和时间。
这篇讲透一件事:背压(backpressure)到底是什么,为什么你的服务会在资源富余的情况下全线崩溃,以及该怎么在自己代码里把它找出来。
一、背压不是背锅,是对话
先说人话。假设你是个餐厅老板(对,就那个永远满员的馆子)。
后厨出菜慢,大堂坐了五十桌,每桌都在等。老板干了件很自然的事:继续放人进来——反正椅子还有空位嘛。等着的人越多,吵得越凶,后厨更慌,出菜更慢,客人开始拍桌子。
这时候正确的做法是什么?三种:
- 拒客:明确告诉后来的人「满了,等位」。这就是拒绝服务、返回 429、熔断降级。
- 降级:给等待的客人上一份简餐/先上茶水。这就是缓存兜底、返回陈旧数据、异步化。
- 扩容后厨:加厨师加灶台。这就是水平扩容。
三种都是背压。而反例只有一个:继续放人,然后祈祷出菜变快。
背压的本质是:下游的承受能力,通过某种信号传递给上游,让上游主动减速。没有传递信号的队列,就是一个会无限膨胀的内存黑洞。
绝大多数线上事故,翻译成餐厅语言就是同一句话:我们在客人还在排队的时候,还在继续放人进来。
二、系统里到底有几层背压
有意思的地方在于,背压不是一个开关,它是一整条链路上层层相扣的对话。每一层都在做同一件事:把压力往回推。
1. TCP 滑动窗口:最底层的对话
发送方一口气发了一大坨数据,接收方缓冲区满了,接收方把窗口大小调小(甚至 0)。发送方 TCP 栈发现窗口关了,就真的停下来等。
这是教科书级的背压:接收方用「窗口」这一个数字告诉发送方「我快撑不住了」。但它只保护内核缓冲区,保护不了你的业务队列——应用层把数据读走了,应用层的队列却爆了,压力原封不动地转移到了你的堆内存里。
这就是为什么一个服务可以「网卡跑满、CPU 不高、然后 OOM」。压力被 TCP 层接住了,然后原封不动地转移到了你的堆内存里。
2. HTTP/2 与 HTTP/3 的流控窗口
HTTP/2 给每个 stream 和整个连接都设了流控窗口。客户端不读数据,服务端发送窗口就被卡住,整个连接上的所有 stream 一起变慢——这就是「一个慢接口拖垮一整条连接」的根因。窗口调大换吞吐,代价是内存峰值;窗口调小换稳定,代价是尾延迟。没有银弹,只有取舍。
3. 数据库:最会假装从容的那一层
数据库不会拒绝你。它会把查询排进队列,然后让你慢慢等。
-- 你以为这是慢查询,其实是队列在前面堵着
SELECT * FROM orders WHERE user_id = 42;
-- 实际执行时间 3.2s
-- 其中 2.9s 是等待前面 300 个查询跑完
数据库的队列是不可见的:连接池的等待、执行计划里的时间、checkpoint 时的 IO 抖动,全都在排队。数据库唯一给你的提示是连接被占满——而这时候问题已经发生很久了。
所以「连接池超时」从来不是根因,它是背压信号终于传到了你脸上。此前的每一毫秒,压力都藏在队列里。
4. 消息队列:唯一「显式」的背压
Kafka/RabbitMQ 这类队列天生带背压,因为消费者拉取消息的速度决定生产者的速度。消费慢,lag 上涨,生产者要么等,要么收到限流。
但这层背压有个致命前提:消费者必须真的被限住。很多消费端写法是「拉到就丢进本地线程池」,本地线程池队列是个无界队列,队列多大?1024?65536?反正默认能撑到 OOM。Kafka 那边看 lag 一切正常,因为 ack 早就提交了。
背压在「拉取」这一步被建立了,在「处理」这一步被切断了。这就是消息队列最常见的假背压。
5. 限流与熔断:主动说「不」
前面四层背压有个共同点:它们都是隐式的,靠队列、窗口、等待来表达压力。真正把「不」说出口的,是限流和熔断。
但限流最容易做错,错在两个极端:
- 太松:阈值 10 万 QPS,等于没限。限流器的作用不是防攻击,是在系统崩溃前主动牺牲一部分请求,保住剩下的。
- 太紧:阈值 100 QPS,正常流量就打满,直接变成自伤型 DDoS。
限流阈值不该靠拍脑袋,也不该照抄大厂的 QPS 数字。正确做法是压测出系统的拐点(延迟开始快速上升的那个点),把阈值设在拐点的 70%~80%,并且按优先级分级——而不是一刀切。
好的限流器像机场的安检:不是把所有人拦在门外,而是让赶时间的人先走、让不急的人慢慢排。坏掉的限流器像一堵墙,然后所有人一起翻墙。
三、怎么在你的代码里找到那个堵点
讲了原理,来看怎么查。别急着上全套 APM,先做一件事:把队列的长度当成一等公民指标来监控。
任何一段「生产者快于消费者」的代码,都必然有一个队列。把它找出来,然后给它一个指标:
// 反面教材:队列是隐形的,堵塞也是隐形的
var jobs = make(chan Task, 1024)
go func() {
for task := range jobs {
go handle(task) // 又开了一层无界!
}
}()
// 正面教材:队列长度可观测,超过阈值就拒绝
var q = make(chan Task, 1024)
func Submit(t Task) error {
select {
case q <- t:
return nil
default:
return ErrOverloaded // 明确说「不接了」
}
}
那个 select ... default 是整套设计里最值钱的一行。它让队列从「隐式缓冲」变成「显式闸门」,压力被立刻推回给上游。
有了队列长度指标后,按这个顺序排查:
- 看队列长度趋势:是一直在涨(消费能力不足),还是尖峰后回落(瞬时突发)?涨但不回落 = 容量问题;涨了会回落 = 突发问题,靠限流+排队兜住。
- 看队列等待时间:长度不大但等待时间长,说明单次处理变慢了,去查下游(DB、下游 RPC)。
- 看丢弃率:有丢弃说明背压链路是通的,没有丢弃且队列在涨,说明背压没建立。
- 看 CPU 和内存:如果它们都不高,说明瓶颈在等待,不在计算。等待型瓶颈加机器没用,加并发只会让队列更长。
第四点值得单独强调,因为它是最常见的误判。等待型瓶颈(等数据库、等锁、等下游 RPC、等磁盘 IO)加机器是无效的,CPU 再高也没用,因为大家都在等那一个慢东西。这时候该做的是:改查询、加索引、加重试退避、或者把同步调用改成异步。
四、五个真正能落地的做法
- 所有队列都要有界。无界队列就是把「立即失败」拖成「迟早 OOM」。Java 的 ThreadPoolExecutor 默认用无界 LinkedBlockingQueue 配 Integer.MAX_VALUE,等于给生产环境装了一个弹簧。
- 连接池要有排队上限和等待超时。拿不到资源就快速失败,比让请求堆在池外排队到超时更快、更省。
- 给每个外部依赖设超时,并且超时必须小于上游的容忍度。这是典型的超时预算(timeout budget)问题:下游 3 秒超时,上游 5 秒超时,那么剩下的 2 秒是给序列化、网络、重试用的。链路上每一跳都设成 30 秒,只会让调用方等到天荒地老。
- 重试要带退避和抖动。没有抖动的重试会在故障恢复瞬间形成重试风暴,把刚缓过来的服务再打下去一次。固定 100ms 间隔的重试,等于一万个客户端同时在同一毫秒敲你的门。
- 别用「异步」当背压的替代品。把同步调用改成丢进队列,只是把「立刻失败」变成了「延后失败」,而且失败得更难排查。异步化解决的是响应延迟,不是过载。真正解决过载的是有界队列 + 快速拒绝 + 降级兜底。
五、最后
很多架构文章喜欢讲「高可用」「弹性」,但真正的生产系统里,第一杀手从来不是宕机,而是慢慢变慢直到全部请求同时超时。宕机会告警,会有人来救;而缓慢劣化只会在监控曲线上留下一条慢慢爬升的线,等你注意到的时候,整条曲线已经垂直上升了。
所以,下次再看到 CPU 只有 20% 但接口却在超时,别再怀疑监控坏了,也别急着加机器。先问三个问题:
我的队列有多长? 我的请求在等谁? 我有没有办法说「不」?
能回答这三个问题的系统,撑得住意外;回答不了的,系统离雪崩只差一个流量高峰。
而背压这东西,说白了就是一句老话,只是很多人被教歪了:不会拒绝的服务,终究会被请求淹没。
系统和人一样,最要紧的能力不是永不拒绝,而是知道什么时候该说不。