04.7.5 并发与并行:GIL、线程、进程与 asyncio
所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.7 Python
覆盖范围
- GIL 的原理、影响与演进(含 free-threading)
- 线程同步原语、死锁、线程安全
- 进程、进程池、进程间通信与启动方式
concurrent.futures、执行器与异常处理- asyncio 与线程/进程的选型
- 并发容量设置、优雅停机与线上排查
04.7.5-001 什么是 GIL?它对 Python 并发有什么影响?
一句话结论
GIL(Global Interpreter Lock)是 CPython 解释器的一把全局互斥锁:同一时刻只有一个线程能执行 Python 字节码。因此多线程无法并行跑 CPU 密集任务,但 IO 阻塞时线程会释放 GIL,所以多线程仍适合 IO 密集场景。
概念解释
- GIL 保护的是解释器内部状态(引用计数、对象分配、GC 标记),不是业务数据。
- 多进程各自有独立解释器与 GIL,因此能真正并行,代价是内存与 IPC 成本。
原理流程
- 持有 GIL 的线程执行字节码,其他线程等待。
- 纯 Python 计算线程之间是“交替执行”,不是并行,多核利用率上不去。
time.sleep、文件/网络 IO、部分 C 扩展调用会释放 GIL,其他线程趁机运行;IO 等待期间可切换,避免串行等待。
代码或图示
# CPU 密集:多线程几乎无加速
# IO 密集:多线程显著加速
from concurrent.futures import ThreadPoolExecutor
with ThreadPoolExecutor(8) as pool:
list(pool.map(fetch, urls))
常见误区
- 以为 GIL 能保证线程安全:它只保证字节码级别的互斥,复合操作(读-改-写)仍会被打断。
- 以为多线程能并行 CPU 密集任务:纯 Python 计算受 GIL 限制,多核并行要靠多进程或释放 GIL 的 C 扩展。
追问
- GIL 能保证线程安全吗?答:不能。它只保证字节码级别的互斥,复合操作(读-改-写)仍会被打断。
- 为什么 IO 密集多线程有效?答:阻塞系统调用期间线程释放 GIL,其他线程可以继续跑。
- 多进程为什么能绕过 GIL?答:每个进程有独立解释器实例和独立 GIL,操作系统负责调度到多核。
04.7.5-002 为什么 CPython 要设计 GIL?去掉它难在哪?
一句话结论
早期为了简化内存管理与 C 扩展生态:引用计数需要原子更新,单锁比每对象加锁成本低、实现简单;大量 C 扩展默认“调用期间持有 GIL”,去掉会引入细粒度锁与巨大兼容成本。
概念解释
- 替代方案(Jython、IronPython)无 GIL,但生态与性能取舍不同。
- 3.13 起提供实验性 free-threading 构建(PEP 703),默认构建仍带 GIL。
原理流程
- 引用计数的增减必须原子,GIL 让
Py_INCREF无需原子指令,单线程性能更好。 - 细粒度锁会带来锁竞争、死锁风险与缓存一致性开销,单线程反而变慢。
- C 扩展生态庞大,很多库依赖 GIL 假设(如静态全局缓存),去掉会破坏兼容。
代码或图示
import sys
print(sys._is_gil_enabled()) # free-threading 构建下才有意义
常见误区
- 以为去掉 GIL 单线程会变快:通常变慢(引用计数要原子操作、锁开销),多核并行才收益。
- 把 GIL 当成语言规范:它只是 CPython 实现,PyPy 也有 GIL,Jython 没有;free-threading 目前为实验构建,生态兼容性仍需验证,生产慎用。
追问
- 去掉 GIL 单线程会变快还是变慢?答:通常变慢(引用计数要原子操作、锁开销),多核并行才收益。
- free-threading 现在能用吗?答:3.13+ 实验构建,生态兼容性仍需验证,生产慎用。
- GIL 是语言规范的一部分吗?答:不是,只是 CPython 实现,PyPy 也有 GIL,Jython 没有。
04.7.5-003 如何判断该用线程、进程还是协程?
一句话结论
IO 密集且需要简单改造:线程池;IO 密集且要极高并发、生态可异步:asyncio;CPU 密集:多进程或 C 扩展/NumPy;混合负载:进程池 + 每进程内异步/线程。
概念解释
- 判断依据不是“哪种更高级”,而是瓶颈在 CPU、磁盘、网络还是下游服务。
- CPU 密集也可用
concurrent.futures.ProcessPoolExecutor或multiprocessing.Pool。
原理流程
- 线程:切换成本低,适合阻塞式 IO 库(
requests、同步驱动),但线程数上百后调度与内存开销明显。 - 协程:单线程万级并发,切换最便宜,要求全链路异步。
- 进程:绕过 GIL 真并行,内存隔离,启动与 IPC 成本高。
代码或图示
from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
# CPU 密集
with ProcessPoolExecutor() as p: p.map(heavy, data)
# 阻塞 IO
with ThreadPoolExecutor(32) as t: t.map(fetch, urls)
常见误区
- 协程不能替代多进程:协程不解决 CPU 并行。
- 线程数盲目开大:IO 密集按并发请求数与等待占比估算,CPU 密集约等于核数;多进程内还可再起线程池/事件循环。
追问
- 线程数开多少?答:IO 密集按
并发请求数 × 单请求等待占比估算,常见几十到数百;CPU 密集约等于核数。 - 协程能替代多进程吗?答:不能,协程不解决 CPU 并行。
- 多进程里还能开线程吗?答:可以,每个进程内可再起线程池/事件循环。
04.7.5-004 Lock 和 RLock 有什么区别?
一句话结论
Lock 是普通互斥锁,不可重入;RLock 是可重入锁,同一线程可多次获取,需等次数释放。递归调用或同一线程内嵌套加锁的场景要用 RLock,否则会自死锁。
概念解释
with lock:是推荐写法,异常也会释放。- 锁的粒度要小:只保护共享状态读写,不要包住 IO 或长计算。
原理流程
- Lock 内部状态为已获取/未获取,同一线程再次 acquire 会阻塞自己。
- RLock 记录持有线程与获取计数,同线程重复获取只增加计数,释放时递减到 0 才真正释放。
lock.acquire(timeout=...)可避免无限等待;acquire(blocking=False)非阻塞尝试。
代码或图示
import threading
lock = threading.Lock()
counter = 0
def inc():
global counter
with lock:
counter += 1
常见误区
RLock不能跨线程重入:只对持有它的线程可重入,性能略低于 Lock。- 锁只解决互斥,不解决可见性与顺序问题;死锁常见于“两个锁交叉获取”,需固定加锁顺序。
追问
- 为什么
Lock不可重入?答:同一线程再次 acquire 会阻塞自己,造成自死锁。 RLock能跨线程重入吗?答:不能,只对持有它的线程可重入。- 锁能保护一切吗?答:不能,锁只解决互斥,不解决可见性与顺序问题;Python 有 GIL 但复合操作仍需锁。
04.7.5-005 死锁产生的条件是什么?工程上怎么避免?
一句话结论
死锁需要四个条件同时满足:互斥、持有并等待、不可剥夺、循环等待。工程上通过“固定加锁顺序、使用超时、缩小锁粒度、避免嵌套锁、用单一线程/队列串行化”来破坏其中至少一个条件。
概念解释
- 数据库行锁也会死锁,需要按固定顺序更新、缩短事务。
- 排查:
faulthandler.dump_traceback_later、py-spy dump、gdb看线程栈。
原理流程
- 线程 A 拿锁 1 等锁 2,线程 B 拿锁 2 等锁 1,形成循环等待。
- 所有线程都持有部分资源并等待另一部分,无法推进。
- 统一加锁顺序、超时回滚释放已持有锁、或用单线程/队列串行化破坏循环等待。
代码或图示
# 统一顺序:始终先 lock_a 再 lock_b
def worker():
with lock_a:
with lock_b:
...
常见误区
- 超时只能打破僵局,仍需修复加锁顺序,否则会周期性失败。
- “持有并等待”最容易被忽视:业务代码常在持锁时调用下游,下游回调又拿同一把锁;多进程下信号量、文件锁、队列满/空互等也可能死锁。
追问
- 死锁能靠超时“解决”吗?答:只能打破僵局,仍需修复加锁顺序,否则会周期性失败。
- 为什么“持有并等待”最容易被忽视?答:业务代码常在持锁时调用下游,下游回调又拿同一把锁。
- 多进程也会死锁吗?答:会,信号量、文件锁、队列满/空互等都可能死锁。
04.7.5-006 Condition、Event、Semaphore 各自适合什么场景?
一句话结论
Condition 用于“等待某条件成立”(生产者-消费者、状态变化);Event 是单次/多次的布尔开关,适合“通知所有等待者开始/停止”;Semaphore 限制同时访问资源的数量(连接池、限流)。
概念解释
Event.set()后所有wait()立即返回,clear()复位。- 这些原语都可加
timeout,避免永久阻塞。
原理流程
- Condition 配合锁使用,
wait()释放锁并阻塞,notify/notify_all唤醒等待者重新检查条件。 - Event 内部维护布尔标志,
wait阻塞到标志被 set。 - Semaphore 内部计数,
acquire递减、release递增,BoundedSemaphore防止 release 超过初值。
代码或图示
cond = threading.Condition()
items = []
def consumer():
with cond:
while not items:
cond.wait()
return items.pop()
def producer(x):
with cond:
items.append(x)
cond.notify()
常见误区
- 等待条件必须用
while not cond:循环,防止虚假唤醒;被唤醒后条件可能又被别人改掉,需重新检查。 Semaphore只能限并发数量,不能复用连接与做健康检查;单一开关用 Event,有具体谓词条件用 Condition。
追问
- 为什么
wait要用 while 而不是 if?答:被唤醒后条件可能又被别人改掉,需重新检查。 Event和Condition怎么选?答:单一开关用 Event;有具体谓词条件用 Condition。Semaphore能替代连接池吗?答:只能限并发数量,不能复用连接与做健康检查。
04.7.5-007 queue.Queue 怎么实现生产者-消费者?为什么比手写锁更好?
一句话结论
Queue 内部用 Condition + 双端队列实现,put/get 自带阻塞与唤醒,task_done/join 支持任务完成跟踪,maxsize 提供背压。它把“锁、条件、边界”封装好,避免手写同步出错。
概念解释
maxsize=0表示无界,生产过快会 OOM。- 多消费者时天然负载均衡,无需自己分配。
原理流程
put入队,队列满时阻塞等待空位;get出队,队空时阻塞等待元素。- 每次进出队通过 Condition 通知等待方。
task_done标记任务完成,join等待所有已 put 任务被标记完成。
代码或图示
from queue import Queue
q = Queue(maxsize=100)
def producer():
for x in source:
q.put(x)
q.put(None) # 毒丸
def consumer():
while (x := q.get()) is not None:
handle(x)
q.task_done()
常见误区
put_nowait满则Full,get_nowait空则Empty,需自行处理。- Queue 线程安全但多进程不共享,需
multiprocessing.Queue;队列满时生产者阻塞形成背压,无界则内存先崩。
追问
- 为什么用毒丸而不是
daemon直接退出?答:毒丸让消费者优雅结束并完成在途任务。 Queue线程安全吗?答:是,内部加锁;但多进程不共享,需multiprocessing.Queue。- 队列满时生产者会怎样?答:阻塞,形成背压;若无界则内存先崩。
04.7.5-008 ThreadPoolExecutor 怎么用?常见坑有哪些?
一句话结论
用 ThreadPoolExecutor(max_workers=n) 提交任务,submit 返回 Future,map 批量映射;用 with 管理生命周期。坑包括:忘记 shutdown 导致进程不退出、异常被 Future 吞掉、提交不可控数量任务导致内存暴涨、在任务里再向同一池提交造成饥饿死锁。
概念解释
map会立即提交所有任务(3.14 前不惰性),大数据量要分批。- 线程池不隔离上下文,
threading.local与日志上下文需显式传递。
原理流程
- 任务提交后进入池队列,工作线程取出执行。
- 结果/异常保存在 Future 中,
result()取回时才抛出任务内异常。 as_completed按完成顺序产出 Future,适合进度条与超时。
代码或图示
from concurrent.futures import ThreadPoolExecutor, as_completed
with ThreadPoolExecutor(max_workers=16) as pool:
futures = [pool.submit(fetch, u) for u in urls]
for f in as_completed(futures):
try:
print(f.result())
except Exception as e:
print("fail", e)
常见误区
- 任务异常保存在 Future 里,不取
result()或exception()就无人知晓,会静默丢失。 - 池内任务等待同池任务完成会死锁(线程全被占满);
future.cancel()只能取消未开始的任务,已运行无法中断。
追问
- 为什么任务异常会“消失”?答:异常保存在 Future 里,不取
result()或exception()就无人知晓。 max_workers怎么设?答:IO 密集可远大于核数(几十~上百),CPU 密集约核数或核数+1。- 怎么取消任务?答:
future.cancel()只能取消未开始的任务,已运行无法中断。
04.7.5-009 ProcessPoolExecutor 有什么限制?
一句话结论
进程池绕过 GIL 实现真并行,但任务参数与返回值必须可 pickle,进程启动成本高(尤其 spawn),子进程异常需通过 future 取回,全局状态与连接不共享,Windows/macOS 默认 spawn 带来导入副作用。
概念解释
- 传 lambda、局部函数、打开的文件句柄、数据库连接都不可 pickle。
- 需要共享状态时用
Manager、共享内存或外部存储。
原理流程
- 主进程把任务函数与参数 pickle 后发给子进程。
- 子进程导入可定位的顶层函数,执行后把返回值 pickle 回传。
- 子进程崩溃(segfault)会让 future 抛
BrokenProcessPool。
代码或图示
from concurrent.futures import ProcessPoolExecutor
def heavy(n): return sum(i * i for i in range(n))
if __name__ == "__main__": # spawn 模式下必需
with ProcessPoolExecutor() as p:
print(list(p.map(heavy, [10**6] * 4)))
常见误区
- 大对象传输走序列化,IPC 开销可能抵消并行收益;子进程独立内存,模块级缓存需重新加载。
- 进程池不适合小任务:启动与序列化成本大于收益;大对象应用共享内存、文件或让子进程自己读取数据源。
追问
- 为什么 Windows 下必须在
__main__保护?答:spawn 会重新导入主模块,缺少保护会递归创建进程。 - 进程池适合小任务吗?答:不适合,启动与序列化成本大于收益。
- 怎么避免大对象传输?答:用共享内存、文件、或让子进程自己读取数据源。
04.7.5-010 进程的启动方式 fork、spawn、forkserver 有什么区别?
一句话结论
fork 复制父进程内存(Linux 默认,快但可能继承锁/连接等不安全状态);spawn 启动全新解释器并重新导入模块(Windows/macOS 默认,安全但慢);forkserver 先起一个干净的服务进程再 fork(较安全、比 spawn 快)。
概念解释
- 数据库连接、事件循环、线程池在 fork 后不可复用,需在子进程重建。
- 需要确定性时显式
multiprocessing.set_start_method("spawn")。
原理流程
- fork:内核复制父进程地址空间与文件描述符,子进程只保留当前线程。
- spawn:启动新解释器、导入主模块、仅传递 pickle 后的启动参数。
- forkserver:预先起一个干净服务进程,后续从它 fork,避免继承父进程线程/锁状态。
代码或图示
import multiprocessing as mp
if __name__ == "__main__":
mp.set_start_method("spawn")
...
常见误区
- fork 后子进程继承的锁可能处于被其他线程持有的状态,永久阻塞;多线程 fork 极易死锁。
- spawn 模式下主模块必须能被导入(需
if __name__ == "__main__"保护);启动方式默认值随平台与版本变化,显式指定更稳。
追问
- 为什么多线程程序 fork 危险?答:子进程只保留当前线程,但继承的锁可能处于被其他线程持有的状态,永久阻塞。
- macOS 为什么默认 spawn?答:系统 API 限制与 fork 安全性问题(Objective-C 运行时)。
- forkserver 的优势?答:从干净进程 fork,避免继承父进程的线程/锁状态。
04.7.5-011 进程间通信有哪些方式?
一句话结论
常用四类:multiprocessing.Queue(消息队列,支持多生产者多消费者)、Pipe(双向/单向管道,轻量但只适合两方)、Manager(代理共享对象,灵活但慢)、共享内存(shared_memory/Value/Array,最快但需自己同步)。
概念解释
- Queue 基于管道 + 锁 + feeder 线程,数据要 pickle。
- 生产跨主机直接用 Redis/RabbitMQ/Kafka,不要用 multiprocessing 原语。
原理流程
- Queue 通过管道在进程间传递 pickle 后的数据,内部锁与 feeder 线程协调。
- Pipe 两端
send/recv成对使用,只适合两方通信。 - Manager 启动管理进程,代理对象每次访问走一次 IPC;共享内存映射同一块物理内存,由调用方自行加锁。
代码或图示
from multiprocessing import Process, Queue
def worker(q):
q.put("done")
if __name__ == "__main__":
q = Queue()
p = Process(target=worker, args=(q,))
p.start(); print(q.get()); p.join()
常见误区
- Pipe 双方同时读写易死锁;Queue 有时“卡住” join,是因为数据留在缓冲区未 flush,需先取空队列再 join。
- Manager 每次访问都是一次 IPC 往返 + 序列化,性能差;共享内存多个进程同时写同一块内存仍会竞态,需要加锁。
追问
- 为什么 Queue 有时会“卡住”join?答:子进程把数据放进缓冲区但未 flush,需先取空队列再 join。
- Manager 为什么慢?答:每次访问都是一次 IPC 往返 + 序列化。
- 共享内存需要加锁吗?答:需要,多个进程同时写同一块内存仍会竞态。
04.7.5-012 为什么多进程代码里经常遇到 pickle 报错?
一句话结论
多进程传参、返回值、队列消息都要序列化。lambda、嵌套函数、类实例(含不可序列化字段)、打开的文件/连接、生成器、线程锁都不可 pickle,因此会报 AttributeError: Can't pickle ... 或 PicklingError。
概念解释
- 顶层函数与类可 pickle(按模块 + 限定名查找),
__main__中定义的类在 spawn 下可能找不到。 dill/cloudpickle可序列化更多类型,但跨环境兼容性差。
原理流程
- 序列化按“模块路径 + 限定名”还原对象,lambda/嵌套函数没有稳定路径。
- 实例属性里有连接池、锁、事件循环时,需实现
__getstate__/__setstate__剔除。 - 大对象序列化开销高,考虑传路径/ID 让子进程自己加载。
代码或图示
class Task:
def __getstate__(self):
d = self.__dict__.copy()
d.pop("conn", None) # 剔除不可序列化字段
return d
常见误区
- 队列消息大小受 OS 缓冲限制,超大消息应写文件再传路径。
- 多进程里不能传数据库连接:连接含 socket 与状态,必须子进程自建;
__getstate__在 pickle 序列化对象前调用,用返回值替代__dict__。
追问
- 为什么 lambda 不能 pickle?答:没有稳定模块路径与名字,无法在另一进程还原。
__getstate__何时调用?答:pickle 序列化对象前,用返回值替代__dict__。- 多进程里能传数据库连接吗?答:不能,连接含 socket 与状态,必须子进程自建。
04.7.5-013 threading.local 有什么用?原理是什么?
一句话结论
threading.local 为每个线程提供独立属性副本:同一个 local 对象在不同线程访问 x.name 得到各自的值。常用于请求上下文、数据库连接、随机数生成器隔离。底层按线程 ID 存字典。
概念解释
- 协程不适用:同一线程内多个协程共享同一线程的 local,需要
contextvars。 - Web 框架(Flask 的
g、Django 的请求上下文)历史上依赖线程本地/上下文变量。
原理流程
- local 对象内部按线程 ID 维护各自的属性字典。
- 某线程访问属性时,从自己的字典读写,互不影响。
- 线程结束时对应数据随之回收(依赖线程对象销毁)。
代码或图示
import threading
ctx = threading.local()
def handler():
ctx.user = "ann"
print(ctx.user)
常见误区
- 线程池复用线程会导致上一个请求的 local 数据残留到下一个请求,造成串号,需要每次任务开始重置。
- 协程里不能用 local:同一线程内多个协程交替执行,共享同一份 local;异步上下文用
contextvars.ContextVar,支持上下文复制与隔离。
追问
- 线程池复用线程会导致什么?答:上一个请求的 local 数据残留到下一个请求,造成串号。
- 协程里为什么不能用?答:同一线程内多个协程交替执行,共享同一份 local。
- 怎么在异步中传上下文?答:
contextvars.copy_context()或框架的请求上下文机制。
04.7.5-014 守护线程(daemon)和非守护线程有什么区别?
一句话结论
守护线程在主线程退出时被强制结束,不保证清理;非守护线程会阻止进程退出,直到执行完。后台轮询、心跳可用守护线程,需要落盘/提交的任务必须非守护并显式 join。
概念解释
thread.daemon = True必须在start()前设置。- 进程退出前应显式停止循环(Event/标志位)并 join。
原理流程
- 解释器退出时等待所有非守护线程结束。
- 守护线程在主线程退出时被“突然杀死”,
finally不保证执行。 ThreadPoolExecutor的工作线程默认非守护,with退出会等待任务完成。
代码或图示
t = threading.Thread(target=heartbeat, daemon=True)
t.start()
常见误区
- 守护线程中的
finally不保证执行,可能丢数据;退出时锁可能保持占用。 - 以为守护线程能安全写文件:退出时可能写到一半;
ThreadPoolExecutor工作线程非守护,解释器join所有非守护线程,会导致进程不退出。
追问
- 守护线程能安全写文件吗?答:不保证,退出时可能写到一半。
- 主线程结束后守护线程立刻停吗?答:解释器关闭时终止,不执行清理。
- 为什么
ThreadPoolExecutor会导致进程不退出?答:其工作线程非守护,解释器join所有非守护线程。
04.7.5-015 GIL 存在,为什么还需要自己加锁?
一句话结论
GIL 只保证单条字节码执行时不被打断,不保证多条字节码组成的复合操作原子。x += 1、if not d[k]: d[k] = v、先检查再修改等操作都可能被线程切换打断,必须用锁或原子结构保护。
概念解释
- dict 单次
d[k] = v在 CPython 中通常原子,但“检查 + 写入”不原子。 - 复合业务逻辑跨多个对象时完全不原子。
原理流程
counter += 1实际是 LOAD、ADD、STORE 三条字节码,中间可切换。- list
append在 CPython 中原子,但“读长度再写”不原子。 - 线程在字节码间隙被调度切换,其他线程看到中间状态。
代码或图示
lock = threading.Lock()
def inc():
global n
with lock:
n += 1
常见误区
- 依赖 GIL 的“偶然原子性”是脆弱的实现细节,free-threading 下会失效。
- 标准库没有 atomic 类型;可用锁、队列或第三方原子库,不要把单个 dict/set 操作的原子性推广到复合业务操作。
追问
- 哪些操作在 CPython 中算原子?答:单个 dict/set 操作、list.append、
x = y绑定等,但不应依赖。 - 为什么 free-threading 下更危险?答:没有 GIL 后原本“碰巧安全”的代码会暴露竞态。
- 用
atomic类型能解决吗?答:标准库没有;可用锁、队列或第三方原子库。
04.7.5-016 什么是竞态条件?写一个典型例子。
一句话结论
竞态条件指结果依赖线程/进程的执行时序,同样的输入可能得到不同结果。典型是“读-改-写”不加锁:两个线程同时读到 0,各自加 1 写回,最终得到 1 而不是 2(丢失更新)。
概念解释
- 计数器、库存扣减、余额更新是业务中最常见的竞态点。
- 复现困难,需用压测、
sys.setswitchinterval(0.000001)放大切换频率。
原理流程
- 线程 A 读到 n=0,线程 B 也读到 n=0。
- 各自在本地加 1。
- 先后写回,最终 n=1,丢失一次更新。
代码或图示
n = 0
def add():
global n
tmp = n
tmp += 1
n = tmp # 两步之间可能被切换
常见误区
- 检查后执行(check-then-act)与懒初始化同样存在竞态:两个线程可能都通过检查,创建两个实例。
- 解决方法:互斥锁、原子操作(数据库
UPDATE ... SET x = x + 1)、单线程串行化、乐观锁(版本号);竞态窗口极小,测试需并发压力与人为插入延迟。
追问
- 数据库层怎么避免丢失更新?答:
UPDATE t SET stock = stock - 1 WHERE id=? AND stock > 0单语句原子。 - 乐观锁怎么做?答:带版本号更新,版本不匹配则重试。
- 为什么测试很难发现?答:竞态窗口极小,需并发压力与人为插入延迟。
04.7.5-017 线程池大小应该怎么设置?
一句话结论
CPU 密集:约等于核数(或核数 + 1,用于掩盖偶发阻塞);IO 密集:按 核数 × (1 + 等待时间/计算时间) 估算,常见几十到数百。最终要用压测确定,并受下游连接池、内存、文件描述符限制。
概念解释
- 下游连接池大小是硬约束:线程数超过连接数只会让线程排队。
- 异步场景的“并发数”由信号量控制,不是线程数。
原理流程
- CPU 密集线程主要吃核数,过多线程加剧上下文切换。
- IO 密集线程多数时间在等待,可按等待占比放大数量。
- 实测拐点后取 70%~80% 容量,并预留突发余量。
代码或图示
max_workers = min(32, (os.cpu_count() or 1) * 5) # 默认启发式
常见误区
- 线程过多会加剧上下文切换、内存占用(每线程栈约 8MB 虚拟内存)与锁竞争。
- 队列长度决定缓冲能力,无界队列会掩盖过载;线程数并非越多吞吐越高,超过下游容量后延迟上升、错误率升高。
追问
- 为什么默认是
min(32, cpu+4)?答:兼顾 IO 等待与避免线程爆炸,适合一般场景。 - 线程数越多吞吐越高吗?答:不一定,超过下游容量后延迟上升、错误率升高。
- 协程场景怎么定并发?答:按下游 QPS 限额与连接池大小设信号量。
04.7.5-018 concurrent.futures 和 multiprocessing.Pool 怎么选?
一句话结论
优先 concurrent.futures:统一 Future 接口、线程/进程池可互换、异常与超时处理更清晰、与 as_completed 配合好。multiprocessing.Pool 更偏底层,适合需要 imap 惰性、initializer、共享内存原语的场景。
概念解释
ProcessPoolExecutor基于multiprocessing,但 API 更现代。executor支持future.cancel、add_done_callback。
原理流程
- 提交任务得到 Future,结果/异常在 Future 中保存。
executor.map一次性提交;Pool.imap惰性返回结果流。- 项目初始化、模型加载通过
initializer/initargs在每进程执行一次。
代码或图示
from concurrent.futures import ProcessPoolExecutor
with ProcessPoolExecutor() as ex:
for r in ex.map(work, items, chunksize=8):
...
常见误区
- 进程池
max_workers创建时固定,不能动态扩容。 - 异常处理差异:Future 通过
result()抛出,Pool 的apply_async需get();chunksize减少 IPC 次数,任务细小时显著提速。
追问
chunksize有什么用?答:减少 IPC 次数,任务细小时显著提速。- 进程池能动态扩容吗?答:不能,
max_workers创建时固定。 - 异常处理差异?答:Future 通过
result()抛出,Pool 的apply_async需get()。
04.7.5-019 多进程下日志为什么会乱/丢?
一句话结论
每个进程有独立的日志缓冲与文件句柄,多个进程同时写同一文件会交错、覆盖,甚至因缓冲未 flush 丢失。解决:每进程写独立文件、用 QueueHandler/QueueListener 汇总到单写进程,或交给 syslog/集中式日志服务。
概念解释
logging默认按进程独立配置,FileHandler各自持有文件偏移,写入会互相覆盖。- 容器环境优先 stdout,由采集器统一收集。
原理流程
- 各进程 handler 独立缓冲并持有文件偏移。
- 同时写入同一文件时字节交错或覆盖。
- QueueHandler 把日志放进队列,由单独监听线程/进程统一写文件,保证顺序。
代码或图示
from logging.handlers import QueueHandler, QueueListener
handler = QueueHandler(log_queue)
listener = QueueListener(log_queue, FileHandler("app.log"))
listener.start()
常见误区
TimedRotatingFileHandler多进程不安全,多进程同时轮转会冲突。- 日志里应带
processName/pid;异步代码里同步 handler 会阻塞事件循环,需用队列或异步 handler;缓冲未 flush、进程被强杀、队列满时丢弃策略都会导致日志丢失。
追问
- 为什么不直接每个进程写自己的文件?答:可行且最简单,但文件数量与聚合查询成本上升。
TimedRotatingFileHandler多进程安全吗?答:不安全,多进程同时轮转会冲突。- 异步代码里日志要注意什么?答:同步 handler 会阻塞事件循环,用队列或异步 handler。
04.7.5-020 如何优雅停机(graceful shutdown)?
一句话结论
收到 SIGTERM/SIGINT 后:停止接收新请求(关闭监听)→ 等待在途请求完成(设上限)→ 停止线程池/任务队列 → 关闭连接与文件 → 退出。关键是每步都有超时,且信号处理函数只做“置标志”,不做重活。
概念解释
- Web 服务交给 gunicorn/uvicorn 处理优雅停机,配置
graceful_timeout。 - 关闭顺序:先停流量,再停后台任务,最后关资源;反之会丢消息。
原理流程
- 信号处理函数只设置
Event或标志位。 - 主循环检查标志后停止接收新任务。
- 等待在途任务在超时内完成,再关闭线程池、连接与文件。
代码或图示
stop = threading.Event()
signal.signal(signal.SIGTERM, lambda *_: stop.set())
while not stop.is_set():
process_one()
常见误区
- 不能在信号处理里直接做清理:主线程被中断,可能处于任意状态,重入不安全。
- 停机超时后应强制退出并记录未完成任务,避免无限挂起;异步任务要
cancel()并gather(return_exceptions=True)等待收尾;K8s 下terminationGracePeriodSeconds与 preStop 钩子需匹配应用停机时间。
追问
- 为什么不能在信号处理里直接做清理?答:主线程被中断,可能处于任意状态,重入不安全。
- 停机超时后怎么办?答:强制退出并记录未完成任务,避免无限挂起。
- K8s 下要注意什么?答:
terminationGracePeriodSeconds与 preStop 钩子需匹配应用停机时间。
04.7.5-021 定时任务有哪些实现方式?怎么选?
一句话结论
单机简单周期用 threading.Timer/sched 或 APScheduler;需要持久化、分布式、失败重试用 Celery Beat + Broker;系统级用 cron/systemd timer;长任务与 Web 进程分离,避免阻塞请求。
概念解释
sched是标准库调度器,单线程、无持久化,进程退出即丢。- 多实例部署必须做分布式锁/单例调度,否则任务重复执行。
原理流程
- 调度器按 cron/interval/date 规则触发任务。
- 单机调度在进程内线程/线程池执行;分布式由 Beat 投递到 Broker,Worker 消费执行。
- 失败重试、死信处理由任务框架保障。
代码或图示
from apscheduler.schedulers.background import BackgroundScheduler
sched = BackgroundScheduler()
sched.add_job(cleanup, "cron", hour=3)
sched.start()
常见误区
- 多副本下 APScheduler 会重复执行,除非用数据库 JobStore + 分布式锁或只在一个副本启用。
- 任务执行时间超过周期需
max_instances=1与coalesce=True,否则堆积;cron 适合运维脚本,不便于与应用共享代码与配置。
追问
- 多副本下 APScheduler 会重复执行吗?答:会,除非用数据库 JobStore + 分布式锁或只在一个副本启用。
- 任务执行时间超过周期怎么办?答:需
max_instances=1与coalesce=True,否则堆积。 - 定时任务和消息队列任务怎么分工?答:定时负责触发,队列负责削峰、重试与解耦。
04.7.5-022 为什么说“异步任务不要放在 Web 进程里”?
一句话结论
Web 进程的生命周期由请求/部署控制,重启、扩容、超时都会中断后台任务;长任务还会占用 worker 拖慢接口。应把异步任务交给独立 Worker(Celery/RQ/自建消费者),Web 只负责投递与查询状态。
概念解释
- 轻量、毫秒级、可丢的后台动作才适合进程内异步。
- 状态与结果存 Redis/数据库,接口只做“提交 + 查询”。
原理流程
- Web 进程接收请求,把任务投递到队列,立即返回 task_id。
- 独立 Worker 从队列消费、执行、写结果。
- 客户端轮询/回调查询任务状态。
代码或图示
@app.post("/report")
def create_report(req):
task = generate_report.delay(req.id) # Celery
return {"task_id": task.id}
常见误区
- gunicorn 的 worker 会被回收,
threading.Timer与asyncio.create_task都会随进程消失,进程内任务无重试。 - 长任务占用 worker 会降低并发能力,甚至触发超时重试;任务去重需幂等键 + 去重表/分布式锁,失败补偿靠重试 + 退避 + 死信队列 + 人工重放。
追问
- 进程内
create_task会丢任务吗?答:会,进程重启即丢,且无重试。 - 如何保证任务不重复执行?答:幂等键 + 去重表/分布式锁。
- 任务失败怎么补偿?答:重试 + 退避 + 死信队列 + 人工重放。
04.7.5-023 什么是背压?Python 里怎么实现?
一句话结论
背压是“下游处理不过来时,让上游减速或阻塞”,防止队列/内存无限增长。实现手段:有界队列 + 阻塞 put、信号量限并发、异步 await queue.put()、限流与拒绝策略(快速失败)。
概念解释
- 无界队列只是把过载从下游转移到内存,最终 OOM。
- 背压要可观测:队列长度、等待时长、拒绝计数。
原理流程
- 有界队列满时,生产者阻塞在
put,不再继续产生任务。 - 下游消费腾出空位后,生产者被唤醒继续。
- 无法阻塞时使用拒绝策略:返回 429/503,让调用方重试或降级。
代码或图示
q = asyncio.Queue(maxsize=1000)
async def produce(items):
for x in items:
await q.put(x) # 满时挂起
常见误区
- 阻塞生产者可能死锁:若生产者与消费者在同一线程/协程且消费者无法推进,会;需分离执行上下文。
- 队列长度按峰值吞吐 × 可接受延迟估算,并用压测验证;背压是“反馈减速”,限流是“主动限制速率”,常配合使用。
追问
- 阻塞生产者会不会造成死锁?答:若生产者与消费者在同一线程/协程且消费者无法推进,会;需分离执行上下文。
- 队列长度怎么定?答:按峰值吞吐 × 可接受延迟估算,并用压测验证。
- 背压和限流的区别?答:背压是“反馈减速”,限流是“主动限制速率”,常配合使用。
04.7.5-024 多线程程序如何排查卡死/CPU 高?
一句话结论
先抓线程栈:faulthandler.dump_traceback_later(30) 定时打印、py-spy dump --pid 免侵入采样、gdb + py-bt 附加;再看是否死锁(多线程互相等待锁)、是否 GIL 争抢、是否有阻塞 IO。
概念解释
- CPU 高但无进展:可能是忙等、正则回溯、死循环、GIL 频繁切换。
- 线程数暴涨:检查是否重复创建线程池、是否有未回收的线程。
原理流程
- 定时/手动导出所有线程栈,定位阻塞点。
- 多次采样对比栈位置不变,则偏向死锁;热点集中则偏向 CPU 忙等。
- 结合 CPU、锁等待、IO 状态区分根因。
代码或图示
import faulthandler
faulthandler.dump_traceback_later(30, repeat=True)
常见误区
- 容器内可用
py-spy或SIGQUIT+ faulthandler 注册;仅凭现象判断是慢还是死锁容易误判。 - 死锁特征是多次采样栈位置不变且线程都停在 acquire;GIL 争抢优化方向是减少 Python 层计算、用 C 扩展/NumPy、改多进程。
追问
- 为什么
py-spy适合生产?答:采样不侵入、不需要改代码、开销低。 - 怎么确认是死锁而不是慢?答:多次采样栈位置不变,且线程都停在 acquire。
- GIL 争抢怎么优化?答:减少 Python 层计算、用 C 扩展/NumPy、改多进程。
04.7.5-025 为什么多线程下 print/日志会交错?
一句话结论
print 是多次写操作(写内容 + 换行),多线程之间可穿插;logging 的 handler 有锁,单条记录通常完整,但多进程写同一文件仍会交错。异步中同步日志还会阻塞事件循环。
概念解释
- 每条日志应带请求 ID/线程名,便于拼接。
- 高频日志应异步化(QueueHandler)或降级采样。
原理流程
print写内容与换行分多次系统调用,中间可被其他线程穿插。StreamHandler内部加锁,单进程内单条记录完整。- 多进程各自持锁互不感知,写入仍会覆盖。
代码或图示
logging.basicConfig(
format="%(asctime)s %(levelname)s [%(process)d:%(threadName)s] %(message)s"
)
常见误区
- 日志丢失来自缓冲未 flush、进程被强杀、队列满时丢弃策略。
- 异步日志顺序靠单队列单消费者保证,或按请求 ID 聚合;生产默认 INFO,DEBUG 按需动态开启。
追问
- 为什么日志会丢?答:缓冲未 flush、进程被强杀、队列满时丢弃策略。
- 异步日志怎么保证顺序?答:单队列单消费者,或按请求 ID 聚合。
- 生产日志该打什么级别?答:默认 INFO,调试用 DEBUG 并按需动态开启。
04.7.5-026 多进程共享计数器怎么做?
一句话结论
简单计数用 multiprocessing.Value(带锁)或 shared_memory;复杂共享用 Manager().dict()/list()(慢);高并发跨机用 Redis INCR。不要用普通全局变量,进程间不共享。
概念解释
Value("i", 0)默认带RLock,with v.get_lock(): v.value += 1。- 计数器也可用“分片计数 + 汇总”减少争用。
原理流程
- Value/Array 在共享内存映射同一区域,进程直接读写。
- 读-改-写通过内部锁串行化。
- Manager 代理对象每次访问经管理进程 IPC 转发。
代码或图示
from multiprocessing import Value, Process
counter = Value("i", 0)
def work():
for _ in range(1000):
with counter.get_lock():
counter.value += 1
常见误区
- 不用
Value自带锁直接v.value += 1:读-改-写不是原子的,多进程同时加会丢失更新。 - Manager 每次访问都 IPC,适合低频;高频小数据用共享内存,结构复杂低频用 Manager;分布式计数要注意网络分区、超时、幂等重试。
追问
- 为什么
Value需要加锁?答:读-改-写不是原子的,多进程同时加会丢失更新。 Manager和共享内存怎么选?答:高频小数据用共享内存,结构复杂低频用 Manager。- 分布式计数要注意什么?答:网络分区、超时、幂等重试。
04.7.5-027 GIL 下如何真正利用多核?
一句话结论
三条路径:多进程(每进程独立 GIL)、使用释放 GIL 的 C 扩展(NumPy、Pandas、hashlib、zlib、部分加密库)、把热点用 Cython/C/Rust 实现并在计算期间释放 GIL。纯 Python 多线程无法利用多核。
概念解释
- NumPy 的大数组运算在 C 层执行并释放 GIL,可与其他线程并行。
- 多进程 + 共享内存可避免大数据复制。
原理流程
- C 扩展在计算入口释放 GIL,计算期间其他线程可运行。
- 多进程由操作系统调度到不同核,各跑独立解释器。
- Cython 的
with nogil:可显式释放 GIL。
代码或图示
import hashlib
from concurrent.futures import ThreadPoolExecutor
def digest(b): return hashlib.sha256(b).hexdigest()
with ThreadPoolExecutor(8) as p:
list(p.map(digest, blobs))
常见误区
- 不是所有 C 扩展都释放 GIL,取决于实现,未释放的仍串行。
- 多进程并非一定比多线程快:CPU 密集通常占优,但启动与 IPC 成本高,小任务可能更慢;
hashlib对大 buffer 计算摘要、zlib.compress压缩任务可多线程并行。
追问
- 为什么 NumPy 多线程能加速?答:计算在 C 层且释放 GIL,线程可真正并行。
- 所有 C 扩展都释放 GIL 吗?答:不是,取决于实现,未释放的仍串行。
- 多进程一定比多线程快吗?答:CPU 密集通常,但启动与 IPC 成本高,小任务可能更慢。
04.7.5-028 线程和协程可以混用吗?要注意什么?
一句话结论
可以:在线程里跑 asyncio.run,或在协程里用 run_in_executor/to_thread 调阻塞代码,或每线程一个事件循环。注意对象不能跨事件循环使用(Future、Lock、连接),且线程安全要显式保证。
概念解释
asyncio.run在子线程中运行是常见模式(如后台常驻协程)。- 线程池任务不要回调协程对象,需显式调度回原循环。
原理流程
- 子线程内创建并运行独立事件循环。
- 主线程有循环时,用
run_coroutine_threadsafe把协程投递到该循环。 - 协程内通过执行器把阻塞调用交给线程池。
代码或图示
def run_loop():
asyncio.run(main())
t = threading.Thread(target=run_loop, daemon=True)
t.start()
常见误区
- Task 绑定创建它的循环,跨循环
await会 RuntimeError;协程内的asyncio.Lock只对同一循环有效,跨线程需线程锁。 - 数据库/HTTP 客户端通常在连接时绑定循环,不能跨循环复用;线程池任务创建协程后必须回到某个循环执行。
追问
- 为什么不能在不同循环间
await同一个 Task?答:Task 绑定创建它的循环,跨循环会 RuntimeError。 - 怎么从线程安全地投递协程?答:
asyncio.run_coroutine_threadsafe返回 concurrent Future。 - 线程池里能创建协程吗?答:可以创建,但必须回到某个循环执行。
04.7.5-029 多进程部署时如何共享连接池/缓存?
一句话结论
不要跨进程共享连接:每个进程独立建池,按“进程数 × 池大小 ≤ 数据库最大连接”规划;缓存优先用外部 Redis/Memcached,本地缓存只做进程内 L1 并接受不一致。
概念解释
- 本地缓存命中率高但多副本不一致,适合只读配置、字典类数据。
- 进程重启会清空本地缓存,注意缓存雪崩。
原理流程
- 各进程独立建立连接池,连接不跨进程传递。
- 共享数据走外部缓存,本地 L1 只缓存热点只读项。
- 失效通过 TTL、Pub/Sub 广播或版本号同步。
代码或图示
# 每进程独立创建
engine = create_engine(url, pool_size=5, max_overflow=2)
常见误区
- fork 继承的数据库连接在子进程会串数据/协议错乱,必须
close后重建。 - 连接池大小需按总并发反推,避免所有 worker 打满数据库;多级缓存(本地 + Redis)可降低热点压力,但需处理失效广播。
追问
- 为什么 fork 后连接会坏?答:TCP 连接状态被复制,两个进程同时读写同一 socket。
- 本地缓存怎么失效?答:Redis Pub/Sub 广播、TTL、版本号。
- 进程数 × 池大小怎么算?答:按 DB
max_connections留余量反推,别按 CPU 核数拍脑袋。
04.7.5-030 asyncio 里能开线程吗?什么时候需要?
一句话结论
能,用 asyncio.to_thread/run_in_executor。用于三类场景:无法异步化的阻塞库(同步 DB 驱动、requests、文件 IO)、CPU 轻量但会阻塞的计算、需要调用仅同步 API 的第三方 SDK。
概念解释
- 线程池任务无法被协程取消真正中断。
- CPU 密集应使用进程池而不是线程池。
原理流程
- 协程通过执行器把阻塞调用提交到线程池。
- 线程执行完成后把结果/异常交回循环,协程恢复。
- 线程内异常在
await时抛出,需 try/except。
代码或图示
loop = asyncio.get_running_loop()
with ThreadPoolExecutor(10) as pool:
await loop.run_in_executor(pool, blocking_io)
常见误区
- 大量小阻塞调用会因线程切换开销变慢,能异步化就异步化。
- 线程池大小默认受限,重阻塞任务可能排队,可传入自定义
ThreadPoolExecutor;线程一旦开始执行无法强制中断,只能丢弃结果,超时后线程继续执行直到完成,占用池容量。
追问
to_thread用的是哪个池?答:默认循环的默认执行器,可set_default_executor替换。- 为什么线程池任务取消不了?答:线程一旦开始执行无法强制中断,只能丢弃结果。
- 阻塞调用超时后线程会怎样?答:继续执行直到完成,占用池容量。
04.7.5-031 什么是“线程饥饿”?怎么发现?
一句话结论
线程池被少量长任务占满,后续短任务长期排队,表现为延迟飙升但 CPU 不高。发现方式:监控活跃线程数、队列等待时长、任务执行时长分布;修复:隔离池(快/慢任务分开)、限制单任务时长、扩容或异步化。
概念解释
- 常见于“一个池跑所有任务”,慢任务(大文件、外部超时)拖住整池。
- 用独立执行器隔离关键路径与后台任务。
原理流程
- 长任务长期占用池内线程,新任务在队列排队。
- 队列积压导致等待时长上升,CPU 却不高。
- 隔离快慢任务池、加任务超时与熔断,避免无限等待。
代码或图示
fast_pool = ThreadPoolExecutor(16)
slow_pool = ThreadPoolExecutor(4) # 隔离慢任务
常见误区
- 嵌套提交(池内任务再提交到同池)会自锁;同步 HTTP 超时设置过长会长期占线程。
- 异步也可能饥饿:单个协程长时间占用循环(CPU 密集)会饿死其他协程;隔离池会占更多线程,但换来关键路径稳定性。
追问
- 线程饥饿和 CPU 高怎么区分?答:饥饿时 CPU 低、队列长、线程都在等 IO 或锁。
- 为什么异步也可能饥饿?答:单个协程长时间占用循环(CPU 密集)会饿死其他协程。
- 隔离池会不会浪费资源?答:会占更多线程,但换来关键路径稳定性。
04.7.5-032 为什么 fork 之后不能复用父进程的锁和事件循环?
一句话结论
fork 只复制当前线程,其他线程消失,但它们持有的锁状态被复制为“已锁定”,无人释放;事件循环的 selector、唤醒管道、回调队列也被复制,两个进程会争抢同一 fd,行为不可预测。子进程应重建这些运行时对象。
概念解释
asyncio明确要求:fork 后子进程需新建事件循环。os.register_at_fork可注册 fork 后的清理回调。
原理流程
- fork 复制父进程内存与文件描述符,但只留下调用 fork 的线程。
- 其他线程持有的锁处于已锁定状态,子进程无人释放。
- 事件循环内部 fd、回调队列被复制,父子进程同时操作同一资源。
代码或图示
os.register_at_fork(after_in_child=lambda: logging.getLogger().handlers.clear())
常见误区
- 数据库连接、HTTP 连接池、日志 handler 都应重建;继承的 handler 缓冲与文件偏移被复制,子进程日志会重复/丢失。
multiprocessing的 spawn/forkserver 从干净进程启动,规避该问题;fork 后重新初始化连接池必须显式dispose()旧池。
追问
- 为什么子进程里日志会重复/丢失?答:继承的 handler 缓冲与文件偏移被复制。
forkserver为什么更安全?答:从干净的服务进程 fork,不继承业务线程与锁。- 能在 fork 后重新初始化连接池吗?答:能,且必须显式
dispose()旧池。
04.7.5-033 multiprocessing 和 subprocess 有什么区别?
一句话结论
multiprocessing 面向“Python 进程”并行,提供 Pool/Queue/共享内存等高层原语,能 pickle 传参;subprocess 面向“启动外部程序”,通过 stdin/stdout/管道交互,不要求对方是 Python。
概念解释
subprocess.run适合调用 ffmpeg、git、系统命令,可捕获输出与返回码。- 两者都可设置超时,
multiprocessing需自己实现。
原理流程
- multiprocessing 启动新解释器,按 pickle 协议传函数与参数。
- subprocess 创建外部进程,通过管道与其标准输入输出通信。
- 外部工具本身是瓶颈且不适合库化时,可用进程池包一层并发。
代码或图示
subprocess.run(["ffmpeg", "-i", src, dst], check=True, timeout=60)
常见误区
subprocess的shell=True有命令注入风险,避免拼接用户输入。- 大量短命令调用开销大,考虑批处理或原生库;
Popen+stdout=PIPE逐行读实时输出时注意缓冲与死锁。
追问
- 什么时候用 subprocess 做并发?答:外部工具本身是瓶颈且不适合库化时,用进程池包一层。
shell=True有什么风险?答:字符串拼接会被 shell 解释,可注入任意命令。- 怎么拿到子进程实时输出?答:
Popen+stdout=PIPE逐行读,注意缓冲与死锁。
04.7.5-034 如何避免“重复创建线程池/连接池”?
一句话结论
把池的生命周期绑定到应用生命周期:进程内单例(模块级或应用工厂中创建一次),请求处理只借用不创建;用依赖注入/上下文传递,避免在函数内部 ThreadPoolExecutor()。同时确保停机时 shutdown()。
概念解释
- Web 框架用
lifespan/startup钩子初始化,shutdown释放。 - 测试中需提供可替换的池,避免真实线程。
原理流程
- 应用启动时创建一次池,存入全局/工厂对象。
- 请求处理从单例池借用任务执行。
- 应用停机时统一
shutdown()释放。
代码或图示
_pool = None
def get_pool():
global _pool
if _pool is None:
_pool = ThreadPoolExecutor(16)
return _pool
常见误区
- 每个请求新建池会导致线程数爆炸、创建销毁开销大;模块级单例在 fork 后需重建。
- 延迟敏感服务可预热核心线程,减少首请求抖动;监控线程数与队列长度,异常增长及时告警。
追问
- 单例池在 fork 后还有效吗?答:无效,子进程应重建。
- 为什么请求内创建池会拖慢响应?答:线程创建与预热成本计入请求延迟。
- 池要不要预热?答:延迟敏感服务可预热核心线程,减少首请求抖动。
04.7.5-035 并发程序的压测与容量评估怎么做?
一句话结论
先定指标(吞吐、P50/P99 延迟、错误率、资源占用),再用与生产同构的环境压测,逐步加压找到拐点;区分瓶颈在应用(GIL/锁)、下游(DB/缓存)、系统(fd/连接数),最后按拐点的 70%~80% 定容量并留突发余量。
概念解释
- 观察维度:CPU、内存、GC、线程/协程数、连接池使用率、队列长度、下游 RT。
- 压测数据要可复现:固定数据集、清缓存、记录版本与配置。
原理流程
- 定义吞吐、延迟分位、错误率等指标。
- 逐步加压,观察拐点特征:延迟非线性上升、错误率抬头、队列积压。
- 定位瓶颈层级,靠优化或扩容解决,按拐点容量留余量上线。
代码或图示
# locust 简例
from locust import HttpUser, task
class U(HttpUser):
@task
def index(self):
self.client.get("/api/items")
常见误区
- 压测端自身可能成为瓶颈,协程客户端需注意压测端容量。
- 区分“吞吐瓶颈”和“容量瓶颈”:前者靠优化,后者靠扩容;
QPS ≈ 并发数 / 平均延迟,延迟上升会反噬吞吐。
追问
- 为什么压测结果和生产差很多?答:数据量、网络、下游配额、缓存命中率不同。
- 并发数和 QPS 的关系?答:
QPS ≈ 并发数 / 平均延迟,延迟上升会反噬吞吐。 - 如何定位是 Python 侧瓶颈?答:
py-spy火焰图看热点是否集中在解释器/锁。
本节高频题
- GIL 原理与影响(001、002)
- 线程/进程/协程选型(003)
- Lock 与 RLock(004)
- 死锁(005)
- Queue 生产者消费者(007)
- 线程池与进程池(008、009)
- 启动方式 fork/spawn(010)
- pickle 限制(012)
- 复合操作非原子(015、016)
- 线程池大小(017)
- 优雅停机(020)
- 背压(023)
- 多核利用(027)