一个服务从十台扩到二十台,接口反而更慢了。监控上看到数据库连接数从三百涨到六百,而数据库的最大连接数配置是五百,多出来的连接被拒绝,应用侧的重试又把压力放大。开发的第一反应是「数据库连接池调大」,运维的第一反应是「数据库 max_connections 调大」,两边都调了,问题变成「数据库 CPU 打满」。真正的解法是反过来算:数据库能承受多少连接,再倒推每个实例的池子该设多大。

这类问题的共同点是:每个资源都有上限,而扩容会成倍放大对共享资源的占用。连接、内存、文件句柄、线程,四本账要一起算,不能只看 CPU。

这篇给四个能直接套用的算式:用利特尔定律估并发、用并发反推连接池、用键数和对象大小估内存、用线程数和耗时估吞吐与排队。数字来自本机模型,可以直接复现;数据库连接数、缓存内存与淘汰在本机 MySQL 8.0.12 和 Redis 5.0.14.1 上取了真实值,其余参数标注「未实测」。

先认出现象:资源账没算,扩容会反噬

下面这些现象,表面看是「机器不够」,实际是某本账超了。

现象真实原因第一步查什么
扩容后数据库连接被拒绝实例数乘以单实例池上限,超过数据库最大连接数算总连接数,对比数据库配置与当前连接数
内存没满却频繁触发淘汰只算了数据本身,没算对象开销、碎片和副本看 used_memory 与业务键数的比例
服务随机报「打开文件过多」连接、客户端、日志文件加起来超过句柄上限看进程的 fd 数量与 ulimit
CPU 不高但接口排队严重线程池太小,或在等锁、等 IO看线程池活跃数、队列长度与单请求耗时
连接池利用率九成后延迟陡增排队进入非线性区间,等待时间指数上升看池利用率与 p99 等待时间的关系
单实例压测很好,多实例上线就崩共享资源(数据库、缓存、下游)被打满按总量而不是单实例量重新算
内存估算和实际差一倍漏算序列化开销、索引结构、副本用真实键采样估算单键占用
线程数调大后吞吐没涨瓶颈在下游或锁,不在线程看下游耗时与锁等待,而不是继续加线程

并发怎么估:利特尔定律

利特尔定律说的是:系统里的平均并发数,等于到达速率乘以平均停留时间。用请求来说,并发等于每秒请求数乘以单请求耗时。这个式子不需要复杂模型,只要两个数。

本机模型:二万 QPS、单请求二十五毫秒,并发是五百。分到二十个实例,每个实例平均二十五個并发。这个「平均」很重要:它是时间平均,不是峰值。峰值可能是平均的两到三倍。

Little 定律:2 万 QPS × 25ms = 500 个并发请求
20 个实例:每个约 25 个并发

估容量时要用峰值 QPS 和接近峰值的耗时,而不是平均值。如果峰值是平均的三倍,并发就是一千五百,每个实例七十五个,连接池和线程池都要按这个数配。

还要注意「耗时」包含等待。请求在队列里等了一百毫秒,也算在停留时间里。用「服务时间」算会低估并发,用「端到端时间」算会高估,因为端到端包含了客户端和网络。最稳妥的是用应用内部的处理时间,再加一点余量。

举个容易犯错的例子:某接口平时二十毫秒,压测时数据库变慢,耗时涨到二百毫秒。QPS 没变,但并发需求涨了十倍,连接池和线程池立刻不够。扩容前先看耗时有没有变化,比直接加机器有效。

连接池:从数据库上限倒推

连接池的设置要分两步:先算需要多少并发连接,再看数据库能接受多少。顺序反了,就会出现「每个实例都觉得自己很合理,加起来把数据库打穿」。

本机模型:二十个实例,每个池子上限三十,总连接是六百;数据库最大连接数五百,超出两百。这还没算上运维工具、批处理任务、主从复制的连接。实际能用的余量更小。

每实例池 30:20 实例 × 30 = 600 个连接
MySQL max_connections = 500:超出 100 个

正确顺序是:先定数据库能承载的连接上限,减去预留,再除以实例数,得到每个实例的池子上限。比如数据库五百、预留一百、二十个实例,每个实例最多二十。这个数再和「并发需求」对比,如果不够,要么加数据库、要么加中间层、要么减少实例数,不能硬超。

池子不是越大越好。连接本身占数据库内存,每个连接还有上下文切换成本。连接数超过数据库的最佳并发后,吞吐不会涨,延迟反而升。连接池的价值是「复用连接、限制并发」,不是「越多越快」。

池子被占满时,应用会阻塞在获取连接上。这个等待通常不算在「数据库耗时」里,监控上看起来数据库很闲,接口却很慢。所以要看「获取连接的等待时间」这个指标,不能只看 SQL 执行时间。

内存账:键数、对象开销、碎片、副本

缓存内存不能只按「键大小加值大小」算。每个键还有对象头、指针、过期时间、哈希表开销,实际占用往往是裸数据的一点五到两倍。

本机模型:一千万个键,键三十二字节、值六十四字节、每个键固定开销五十六字节。裸数据是 1.42GB;按一点二倍碎片算是 1.70GB;主从两份就是 3.40GB。这个数字还没算上复制缓冲、AOF 文件、客户端输出缓冲。

1000 万键(32B key + 64B value + 56B overhead):
裸数据 1.42 GB,1.2 倍碎片 1.70 GB,主从 3.40 GB

估算时最好用真实采样:取一千个典型键,用内存分析工具看单个占用,再乘以总数。不同数据结构(字符串、哈希、列表、集合)的开销差别很大,用平均值会失真。

还要留出「增长和淘汰」的空间。内存用到九成时,淘汰会变得频繁,命中率下降;主从切换、全量同步时,内存还会短时翻倍。生产上一般把水位控制在七成到八成,不要等满了再加。

容器里跑缓存还要注意「容器内存限制」和「缓存自身上限」的关系。缓存上限设得比容器限制还高,进程会被系统直接杀掉,而不是优雅淘汰。两个数要一起设,缓存上限留出进程本身的开销。

文件句柄:最容易漏的一本账

每个网络连接、每个打开的文件、每个日志句柄都占一个文件描述符。单个进程的句柄上限通常是 1024 或更高,但很容易被忽视。

本机模型:每个应用实例,连接池三十个、客户端连接三百个、文件与日志一百个,合计四百三十个;上限一千零二十四时,余量五百九十四个。看起来够,但如果客户端连接涨到六百,余量只剩两百,再叠加临时文件和管道,就会碰到上限。

每实例 fd:连接池 30 + 客户端 300 + 文件日志 100 = 430
ulimit 1024 时余量 594

句柄耗尽的表现很有迷惑性:不是「连接太多」的报错,而是「打开文件过多」「无法创建线程」「连接超时」这类杂乱的错误。排查时要看进程的 fd 数量和类型分布,而不是只看连接数。

调整上限能缓解,但不能替代治理。句柄泄漏、连接不关闭、日志文件不轮转,才是根因。先把「打开的都关掉」做到,再谈调大上限。

句柄泄漏的典型特征是「数量随时间单调上升,重启后归零」。如果 fd 曲线是锯齿状、随流量波动,通常是正常的连接开闭;如果是一条缓慢上升的直线,就要去查哪里没关。日志文件不轮转也会这样,尤其是按天开新文件却不关旧文件的实现。

线程池:吞吐上限与排队

固定线程池的吞吐上限,等于线程数除以单任务耗时。二百个线程、单任务十毫秒,上限是每秒两万个。超过这个速率,任务开始排队。

本机模型:每秒二万二千个任务,超出上限两千个每秒;六十秒积压十二万个任务,按每个四 KB 算,占用四百六十九 MB。队列不是免费的,积压会吃内存,也会让延迟越来越高。

200 线程、单任务 10ms:上限 20000/s
22k/s 时每秒净排队 2000 个,60 秒积压 12 万个
按 4KB/任务:469 MB

更麻烦的是接近饱和时的排队非线性。连接池二十个、服务时间二十毫秒,利用率七成时排队概率 9.4%,p99 等待七毫秒;利用率八成时排队 25.6%,p99 十六毫秒;九成时 55.1%,p99 四十毫秒;九成五时 75.5%,p99 八十六毫秒。

连接池 20、服务 20ms:
λ=700/s 利用率 70%  排队 9.4%   p99 等待 7ms
λ=800/s 利用率 80%  排队 25.6%  p99 等待 16ms
λ=900/s 利用率 90%  排队 55.1%  p99 等待 40ms
λ=950/s 利用率 95%  排队 75.5%  p99 等待 86ms

这组数字说明:利用率从七成到九成五,只多了二十五个百分点,p99 等待却涨了十二倍。容量规划不能把池子用到九成,七成左右是比较安全的区间;超过八成,延迟开始不受控。

线程数也不是越多越好。线程多了,上下文切换、栈内存、锁竞争都会上升。更好的做法是减少单任务耗时,或者把阻塞调用改成异步,让少量线程处理更多请求。

队列长度要单独监控。队列开始持续增长,说明到达速率已经超过处理能力,这时加线程可能有用,也可能只是把压力更快地传给下游。先看下游有没有被打满,再决定加不加。

什么时候不该按峰值配

按全年最高峰值配资源,一年里大部分时间都在浪费。合理的做法是分级:常态按七成水位配,峰值靠弹性扩容或降级兜住,极端峰值靠限流保护。

对内部工具、后台任务、非核心接口,不需要按核心链路的峰值配。它们可以排队、可以慢,资源应该优先给核心链路。

新业务还没有稳定流量模型时,不要一次配到「理论上够」。先用小容量跑,观察实际的 QPS、耗时分布、连接占用,再按数据调整。拍脑袋配大,会掩盖真实的性能问题。

还要给「故障时的容量」留余量。平时三台机器扛住,挂一台就只剩三分之二;如果平时利用率已经八成,挂一台必然过载。容量规划要按「少一台」算,不是按满员算,这样才能扛住单机故障和发布时的滚动替换。

不要用「平均值」做容量规划。平均值会告诉你「平时够用」,但事故都发生在峰值。至少要拿到 p95 或 p99 的 QPS 与耗时,再留出排队余量。

关键配置样例

下面配置按常见应用与数据库的语义书写。数据库上限取自本机实例,连接池与线程池数值只是示例,实际要按上面的算式算。

# 应用连接池(示例)
datasource:
  maximum-pool-size: 20        # 由数据库上限倒推
  minimum-idle: 5
  connection-timeout: 3000
  idle-timeout: 600000
  max-lifetime: 1800000
  leak-detection-threshold: 60000

# 数据库侧(上限取自本机实例,其余为示例)
max_connections = 500
# 预留 100 给运维、复制、批处理,业务可用 400
# 400 / 20 个实例 = 每实例 20

# 线程池(未实测,示例)
executor:
  core-size: 50
  max-size: 200
  queue-capacity: 1000
  reject-policy: abort

连接池的「最大生命周期」要小于数据库或中间件的空闲断连时间,否则会拿到已经失效的连接。很多「偶发连接错误」都是这个原因,不是网络问题。

线程池的队列不能无限。无限队列会把内存吃光,而且请求等很久才被拒绝,用户已经超时了。有限队列加明确的拒绝策略,能让系统在过载时快速失败,把压力反馈给上游。

怎么验证:命令与成功判据

下面命令用于核对四本账。连接数与上限、缓存内存在本机实跑;文件句柄与线程池指标因 Windows 环境不同,未实测。

# 1. 数据库当前连接数与上限
mysql -e "SHOW STATUS LIKE 'Threads_connected'; SHOW VARIABLES LIKE 'max_connections';"

# 2. 进程的文件句柄数量与上限
ls /proc/$(pgrep -f myapp | head -1)/fd | wc -l
ulimit -n

# 3. 缓存内存与键数
redis-cli info memory | grep -E 'used_memory_human|mem_fragmentation_ratio'
redis-cli dbsize

# 4. 线程池活跃数与队列长度(按框架的指标名调整)
curl -s http://app:8080/actuator/metrics/executor.active
curl -s http://app:8080/actuator/metrics/executor.queued

# 5. 压测时观察延迟与利用率
wrk -t4 -c200 -d60s http://app:8080/api/list
# 本机实际值
# MySQL 8.0.12,主库 3316,默认配置
Threads_connected   2
Threads_running     3
max_connections     151

# Redis 5.0.14.1,端口 6381,maxmemory 32mb
used_memory_human:29.00M
maxmemory_human:32.00M
mem_fragmentation_ratio:1.00
DBSIZE 42141
connected_clients:1
blocked_clients:0

这两组数是当场取的真实值,也说明账要按实例算:本机默认连接上限只有 151,按二十个实例、每池二十算,需求四百已经超过上限两倍多;缓存碎片比正好是一,说明没有明显碎片,但内存已接近上限,再灌数据就会开始淘汰。

成功判据:数据库连接数低于上限并留有余量;进程 fd 数量稳定,不随时间单向增长;缓存内存低于水位线,碎片比在合理范围;线程池利用率在七成左右,队列长度不持续增长;压测的 p99 在预算内,且随并发增加没有出现陡增。

验证要成组做:单独看连接数正常,不代表内存够;单独看 CPU 不高,不代表线程池没排队。四本账要一起看,才能解释「为什么扩容后更慢」。

观察周期要覆盖至少一个完整的业务周期,最好是一周。只看一小时的数据,会把早高峰当成常态,或把夜间低峰当成容量充足。容量规划用的是峰值,不是某个采样点。

边界与代价

资源估算不是精确科学,输入本身就带误差。QPS 会波动,耗时是分布,对象大小不均匀。算出来的数要用「区间」表达,不要给一个看似精确的整数。

留余量是有成本的。CPU 留三成、连接留三成、内存留两成,意味着硬件多花不少钱。这个成本要和「故障时的损失」比较,不是越大越好。核心链路多留,非核心链路少留。

监控本身也占资源。高频采集、全量日志、链路追踪都会消耗 CPU 和存储。可观测性要分级,别让监控把业务压垮。

最后,容量规划要定期重算。业务模式、数据量、依赖性能都在变,半年前算的数可能已经失效。把算式写进文档,比记住结论有用。

还要区分「独占资源」和「共享资源」。CPU、内存是单实例独占的,加机器就能加;数据库连接、缓存、下游接口是共享的,加实例只会让竞争更激烈。扩容前先判断瓶颈在独占侧还是共享侧,这决定了「加机器」有没有用。

另一个常见误区是把「平均利用率」当成容量。CPU 平均五成看着还有余量,但峰值十分钟可能已经打到九成;连接池平均三成,峰值时可能全在排队。容量规划看的是峰值区间的最大值,不是全天平均。用平均值配容量,等于用体温计测血压。

当天能自验的五个练习

一,用利特尔定律算你负责的系统:峰值 QPS 乘以 p95 耗时,得到并发数,再除以实例数。成功判据:结果与监控里的实际并发在同一量级。

二,从数据库最大连接数倒推每个实例的池子上限,再和并发需求对比。成功判据:能说出「池子够不够、不够该加什么」。

三,采样估算缓存内存:取一百个真实键,算平均占用,乘以总键数,再乘碎片和副本系数。成功判据:估算与实际 used_memory 相差不超过三成。

四,数一个进程的 fd:连接、客户端、文件、日志各占多少。成功判据:能列出主要来源,并判断离上限还有多少余量。

五,画一张「利用率与 p99 等待」的曲线:用本机脚本模拟不同到达速率,记录排队比例。成功判据:能看到利用率超过八成后延迟陡增的拐点。

和下一篇的关系

单个中间件的账算完了,接下来把它们拼成一套架构。下一篇进入组合方案,第一站是「请求从 DNS 到数据库的完整路径」:每一跳加多少延迟、哪一跳最容易成为瓶颈、全链路 p99 由谁决定。

这一篇的四个算式要留着:并发等于速率乘耗时,连接从数据库上限倒推,内存要算开销和副本,吞吐等于线程数除以耗时。后面讲集群、降级、迁移,都会用到它们。