一台 4 核 8 GB 的服务器,CPU 使用率常年在 30% 左右,线程数却有两百多个,接口的 P99 从 120 毫秒涨到了 800 毫秒。扩容到 8 核之后,CPU 还是不高,延迟却只降了一点。运维说“资源没跑满,肯定不是容量问题”,开发说“线程都在等,肯定是被下游拖住了”。两个人都有道理,但都没说到关键:线程多不等于并行多,等也不等于没开销。
线程是什么?一句话:进程内部的一条执行流,它共享进程的地址空间和已打开的文件,但有自己的栈、寄存器和程序计数器。一个进程可以有多条线程,同一时刻真正在 CPU 上执行的线程数,不会超过物理核心数(考虑超线程也只是逻辑核心数)。剩下的线程都在排队或等待。
这篇从一次时间片开始,把“同时”这个错觉拆开,再看线程池为什么不能拍脑袋开大,最后解释 Python 里那类“开了线程却没变快”的现象。
现象:任务都在等,CPU 却不高
先建立一个直觉:CPU 是一条流水线,不是魔法。单核上同一时刻只能执行一条指令流,所谓“同时跑十个任务”,是调度器让十个任务轮流上场,每个跑一小段时间,切换得足够快,人就以为它们在同时进行。
如果任务大部分时间在等网络、等磁盘、等锁,CPU 确实会闲下来。但这段时间并没有凭空消失,它变成了线程的阻塞状态。线程数越多,就绪队列和等待队列越长,调度器要管的东西越多,锁竞争和缓存失效也越严重。于是出现一种反直觉的现象:CPU 不高,延迟却高;加机器有一点用,但边际收益很快变零。
还有一种更隐蔽的情况:线程本身没多少活,但切换太频繁。每次切换都要保存现场、恢复现场、换栈,还可能把 CPU 缓存里刚热起来的数据冲掉。线程数远超核心数时,切换开销会从“偶尔发生”变成“主要工作”。
线程数为什么会膨胀到两百多?常见路径是这样:每个请求进来开一条线程,线程里又要等数据库、等缓存、等第三方接口。请求量一上来,线程数就跟着请求量线性增长。表面上看是“一个请求一条线程,逻辑很清晰”,实际上是拿线程当等待容器用。等待本身不贵,贵的是这些线程同时存在带来的栈内存、调度记账和锁竞争。
场景走查:一个时间片里发生了什么
把调度器的一次决策拆成五步看。不同操作系统的细节不同,但骨架一致。
第一步的时钟不是“每秒一次”,而是每个 CPU 核心都有自己的定时器,频率通常在毫秒级。时间片用完只是“该考虑切换”,不一定是立刻切换;如果当前线程优先级很高,或者系统正处在不可抢占的内核路径里,它会继续跑。
第二步保存的不只是几个通用寄存器,还包括浮点寄存器、SIMD 寄存器、条件码,以及线程的栈指针。线程的控制块里还记着它的状态、优先级、等待的原因、所属进程。这些东西合起来叫上下文。
第三步是调度策略真正起作用的地方。最简单的策略是轮转:所有线程排一个队,每人跑一个时间片。现实中的调度器会考虑更多:谁等得久、谁被唤醒后应该抢占、谁是交互型任务、谁已经占用了大量 CPU。Linux 的 CFS 用“虚拟运行时间”来记账,跑得少的线程优先,权重高的线程时间片更长;实时调度则用固定优先级,高优先级只要就绪就能抢占低优先级。
第四步和第五步是第二步的逆操作。这里有一个容易被忽略的成本:如果新线程属于另一个进程,可能还要切换地址空间,页表基址寄存器一换,TLB 里缓存的地址翻译大量失效。跨进程切换通常比同进程内切换更贵。
线程的状态:不是“在跑”和“没在跑”两种
调度器眼里,线程至少有这几种状态。搞清楚状态,才能看懂卡顿到底卡在哪。
“就绪”和“运行”的区别很关键。一个线程可以就绪很久却一直轮不到 CPU,这时候它没有在干活,但延迟在增加。监控里看到线程数很多、CPU 不高,很可能就是大量线程在“就绪”或“阻塞”,而不是在计算。
阻塞又分两种。一种是可中断等待,比如等锁、等条件变量,收到信号可以提前醒来;另一种是不可中断等待,典型是某些磁盘 IO 的内核路径,连终止信号都要等它完成。后者在进程状态里常常显示为 D,用普通手段杀不掉,只能等 IO 返回或重启机器。
切换一次到底贵在哪
上下文切换的成本不是一个固定数字,它取决于切换类型、CPU 架构、缓存状态。经验范围大致在几微秒到几十微秒;跨进程切换通常更贵。单看这个数字不大,但乘以每秒几万次,就会变成实打实的 CPU 开销。
成本主要来自三块。第一块是直接的保存和恢复,寄存器越多、状态越复杂,开销越大。第二块是缓存污染:新线程的代码和数据不在 CPU 缓存里,要重新从内存搬;如果换了地址空间,地址翻译缓存也要重建。第三块是调度器本身的记账和锁,线程越多,运行队列操作越频繁。
所以“多开线程能提高吞吐”有前提:任务的等待时间要足够长,长到切换成本可以忽略;并且线程数不能超过系统能有效调度的范围。反过来,如果任务本身很短、很密集,开一堆线程只会让它们在同一个核心上互相打断。
判断切换是不是瓶颈,不能靠猜。Linux 上可以看 /proc/stat 里的 ctxt 计数,或者用 pidstat -w 看每秒的自愿与非自愿切换;Windows 的性能计数器里有“系统上下文切换/秒”和“线程切换/秒”。把切换曲线和吞吐曲线放在一起看,如果切换数随并发度陡增而吞吐不再上涨,基本就是到拐点了。这些指标只能说明现象,最终还要结合线程栈和锁等待一起判断。
线程池开多大:先分清任务在等还是在算
线程池大小的经典估算,先把任务分成两类。
CPU 密集
任务的大部分时间在计算,几乎不等待。线程数接近物理核心数就够了,多开只会增加切换。常见做法是核心数或核心数加一,留一点余量给偶发的阻塞。
如果有超线程,逻辑核心数可以翻倍,但计算型任务的收益通常达不到翻倍,因为两个逻辑线程共享同一套执行单元。
IO 密集
任务的大部分时间在等网络、磁盘或数据库。线程数可以超过核心数,因为等待时不占 CPU。一个常用估算式是:核心数乘以“一加等待时间除以计算时间”。
这个式子只是起点,不是答案。等待时间会随下游抖动,线程太多又会压垮连接池。最终值要靠压测和监控定,且队列必须有界。
还有一类任务混合了计算和等待,比如先查数据库再序列化结果。这时候可以拆开看:等待部分用异步或更多线程,计算部分限制并发。不要用一个线程池同时扛两种负载,否则一种负载会把另一种拖死。
线程池真正的风险不是“开少了”,而是“队列无限长”。队列一长,请求排队时间就不可控,超时和重试会把压力放大。正确的做法是队列有界,满了就快速失败或降级,让上游知道系统已经过载,而不是默默堆积。
实测:为什么开了线程却没有变快
用 Python 做一个最小实验,对比“CPU 密集”和“IO 等待”两种任务在线程下的表现。本机是 12 个逻辑核心,Python 3.15。
import os, time, threading
def cpu_task():
n = 0
for i in range(3_000_000):
n += i
return n
def sleep_task():
time.sleep(0.5)
print("cpu_count =", os.cpu_count())
t0 = time.perf_counter()
for _ in range(4): cpu_task()
print("sequential cpu 4x = %.3fs" % (time.perf_counter() - t0))
t0 = time.perf_counter()
ths = [threading.Thread(target=cpu_task) for _ in range(4)]
[t.start() for t in ths]; [t.join() for t in ths]
print("threaded cpu 4x = %.3fs" % (time.perf_counter() - t0))
t0 = time.perf_counter()
ths = [threading.Thread(target=sleep_task) for _ in range(8)]
[t.start() for t in ths]; [t.join() for t in ths]
print("8 sleep threads = %.3fs" % (time.perf_counter() - t0))
实际输出:
cpu_count = 12
sequential cpu 4x = 0.267s
threaded cpu 4x = 0.253s
8 sleep threads = 0.502s
两个结论很清楚。四个 CPU 密集任务,串行和四线程几乎一样快,因为 CPython 有全局解释器锁(GIL),同一时刻只允许一条线程执行 Python 字节码,多开的线程只能在锁上排队。八个各睡 0.5 秒的任务,总共只花了 0.5 秒,因为它们等待时会释放 GIL,等待时间真正重叠了。
这不是说 Python 线程没用。IO 密集场景它仍然有效;CPU 密集场景要用多进程、原生扩展,或者换一种运行时。更重要的是,这个实验把“并发”和“并行”分开了:并发是任务在时间上重叠,并行是任务在同一时刻真正各占一个核心。线程能给你并发,能不能并行要看运行时和硬件。
现象对照表
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| CPU 不高,线程数很多,接口还是慢 | 大量线程在就绪或阻塞,调度和锁竞争在消耗时间 | 看线程状态分布和运行队列长度,不只看 CPU 使用率 |
| 加核心后吞吐只涨一点 | 瓶颈在锁、连接池或下游,不在 CPU | 看锁等待时间、连接池排队和下游延迟 |
| 线程数翻倍,耗时也翻倍 | 切换和竞争的开销超过了并行收益 | 对比不同并发度下的吞吐曲线,找拐点 |
| Python 多线程做计算没有加速 | GIL 让同一时刻只有一条线程执行字节码 | 确认任务是 CPU 密集还是 IO 密集,考虑多进程 |
| 线程池队列越来越长,超时变多 | 队列无界,过载被转成排队延迟 | 检查队列容量和拒绝策略,给下游加限流 |
| 程序越跑越慢,重启后恢复 | 线程泄漏或句柄泄漏,资源逐渐耗尽 | 看线程数和句柄数的时间趋势,定位没退出的循环 |
| 高优先级任务反而被低优先级拖住 | 优先级反转:低优先级持锁,中优先级抢 CPU | 检查锁的持有时间和优先级继承设置 |
| 进程状态是 D,杀不掉 | 卡在不可中断的内核等待,常见于磁盘或网络存储 | 看内核日志和 IO 状态,先解决底层阻塞 |
边界与代价
线程的第一个代价是共享。共享地址空间让通信便宜,也让一个线程的野指针能破坏另一个线程的数据。数据竞争不会每次都复现,它依赖执行顺序和缓存时序,所以“我本地跑了一百次都没事”不能证明没有问题。锁能解决竞争,但会引入死锁、活锁和优先级反转,锁的粒度还会直接影响并发度。
第二个代价是栈空间。每条线程都要预留一段栈,Windows 默认通常是一 MB 左右,Linux 常见是八 MB 的虚拟预留。线程数上千时,光是栈的虚拟地址就会吃掉可观的额度。栈大小可以调,但调小会增加溢出风险,递归和大型局部数组要特别小心。
第三个代价是调试和观测。线程的问题往往和时序有关,断点一停,现象就消失。日志里要能看到线程标识和关键状态迁移;线上要有线程栈快照,不能只看一张 CPU 曲线。
第四个代价是“线程不是免费的异步”。有人用大量线程去替代异步 IO,结果线程都卡在等待上,内存和调度开销先崩了。协程是另一个方向:它在用户态切换,成本更低,但一条协程里做了阻塞调用,会把承载它的整条线程一起卡住。选模型之前,先确认你的阻塞点在哪。
在多路 CPU 的机器上还有一层代价:内存访问不是等速的。线程跑在哪个核心、它的数据落在哪块内存,会影响实际延迟。调度器会尽量让线程留在原来的核心上(这叫亲和性),但线程数远超核心数时,这种局部性很难维持,缓存和跨路访问的开销会悄悄上涨。这类问题在单机压测里不一定明显,到了多路服务器上才会暴露。
当天能自己验证的练习
- 把上面的 Python 脚本跑一遍,确认本机的逻辑核心数;把 CPU 任务量调大或调小,观察串行和四线程的差距。
- 把
sleep_task的等待改成 0.1 秒、开 20 条线程,验证总耗时是否仍接近 0.1 秒,理解等待重叠。 - 用
ThreadPoolExecutor分别设 1、4、16 个工作线程跑同一批 IO 任务,记录耗时,找本机的拐点。 - 写两条线程,各自先拿一把锁再去拿对方的锁,用带超时的
acquire观察死锁,再改成固定加锁顺序修好。 - 在 Linux 上用
top -H或ps -L观察一个多线程进程的每条线程,再对比运行前后的线程数。本机没有 Linux 环境,这一条未在本机实测。
小结与下一篇
并发是调度器用时间片切出来的错觉,并行才需要多个核心同时执行。线程有就绪、运行、阻塞、终止几种状态,切换要保存和恢复上下文,还会污染缓存。线程池的大小取决于任务是计算型还是等待型,队列必须有界;Python 的 GIL 则说明了“开了线程”不等于“用了多核”。
下次遇到“CPU 不高但很慢”,先别急着加机器。把线程状态、运行队列、切换次数和锁等待拉出来看一眼,往往能发现瓶颈根本不在算力上,而在线程数量和等待方式上。并发不等于并行,这句话值得贴在显示器边上。
下一篇讲栈、堆和 malloc:内存到底被谁拿走了。线程共享地址空间,接下来就要看清这块空间本身:局部变量放在哪、malloc 要到的内存从哪来、为什么进程占用的内存降不下去,以及内存泄漏和碎片到底有什么区别。