罗罗编程学习记录
本页内容 展开查看

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 成本。

原理流程

  1. 持有 GIL 的线程执行字节码,其他线程等待。
  2. 纯 Python 计算线程之间是“交替执行”,不是并行,多核利用率上不去。
  3. 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。

原理流程

  1. 引用计数的增减必须原子,GIL 让 Py_INCREF 无需原子指令,单线程性能更好。
  2. 细粒度锁会带来锁竞争、死锁风险与缓存一致性开销,单线程反而变慢。
  3. 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。

原理流程

  1. 线程:切换成本低,适合阻塞式 IO 库(requests、同步驱动),但线程数上百后调度与内存开销明显。
  2. 协程:单线程万级并发,切换最便宜,要求全链路异步。
  3. 进程:绕过 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 或长计算。

原理流程

  1. Lock 内部状态为已获取/未获取,同一线程再次 acquire 会阻塞自己。
  2. RLock 记录持有线程与获取计数,同线程重复获取只增加计数,释放时递减到 0 才真正释放。
  3. 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 看线程栈。

原理流程

  1. 线程 A 拿锁 1 等锁 2,线程 B 拿锁 2 等锁 1,形成循环等待。
  2. 所有线程都持有部分资源并等待另一部分,无法推进。
  3. 统一加锁顺序、超时回滚释放已持有锁、或用单线程/队列串行化破坏循环等待。

代码或图示

# 统一顺序:始终先 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,避免永久阻塞。

原理流程

  1. Condition 配合锁使用,wait() 释放锁并阻塞,notify/notify_all 唤醒等待者重新检查条件。
  2. Event 内部维护布尔标志,wait 阻塞到标志被 set。
  3. 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。
  • 多消费者时天然负载均衡,无需自己分配。

原理流程

  1. put 入队,队列满时阻塞等待空位;get 出队,队空时阻塞等待元素。
  2. 每次进出队通过 Condition 通知等待方。
  3. 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 与日志上下文需显式传递。

原理流程

  1. 任务提交后进入池队列,工作线程取出执行。
  2. 结果/异常保存在 Future 中,result() 取回时才抛出任务内异常。
  3. 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、共享内存或外部存储。

原理流程

  1. 主进程把任务函数与参数 pickle 后发给子进程。
  2. 子进程导入可定位的顶层函数,执行后把返回值 pickle 回传。
  3. 子进程崩溃(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")。

原理流程

  1. fork:内核复制父进程地址空间与文件描述符,子进程只保留当前线程。
  2. spawn:启动新解释器、导入主模块、仅传递 pickle 后的启动参数。
  3. 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 原语。

原理流程

  1. Queue 通过管道在进程间传递 pickle 后的数据,内部锁与 feeder 线程协调。
  2. Pipe 两端 send/recv 成对使用,只适合两方通信。
  3. 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 可序列化更多类型,但跨环境兼容性差。

原理流程

  1. 序列化按“模块路径 + 限定名”还原对象,lambda/嵌套函数没有稳定路径。
  2. 实例属性里有连接池、锁、事件循环时,需实现 __getstate__/__setstate__ 剔除。
  3. 大对象序列化开销高,考虑传路径/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 的请求上下文)历史上依赖线程本地/上下文变量。

原理流程

  1. local 对象内部按线程 ID 维护各自的属性字典。
  2. 某线程访问属性时,从自己的字典读写,互不影响。
  3. 线程结束时对应数据随之回收(依赖线程对象销毁)。

代码或图示

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。

原理流程

  1. 解释器退出时等待所有非守护线程结束。
  2. 守护线程在主线程退出时被“突然杀死”,finally 不保证执行。
  3. 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 中通常原子,但“检查 + 写入”不原子。
  • 复合业务逻辑跨多个对象时完全不原子。

原理流程

  1. counter += 1 实际是 LOAD、ADD、STORE 三条字节码,中间可切换。
  2. list append 在 CPython 中原子,但“读长度再写”不原子。
  3. 线程在字节码间隙被调度切换,其他线程看到中间状态。

代码或图示

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) 放大切换频率。

原理流程

  1. 线程 A 读到 n=0,线程 B 也读到 n=0。
  2. 各自在本地加 1。
  3. 先后写回,最终 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 + 等待时间/计算时间) 估算,常见几十到数百。最终要用压测确定,并受下游连接池、内存、文件描述符限制。

概念解释

  • 下游连接池大小是硬约束:线程数超过连接数只会让线程排队。
  • 异步场景的“并发数”由信号量控制,不是线程数。

原理流程

  1. CPU 密集线程主要吃核数,过多线程加剧上下文切换。
  2. IO 密集线程多数时间在等待,可按等待占比放大数量。
  3. 实测拐点后取 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。

原理流程

  1. 提交任务得到 Future,结果/异常在 Future 中保存。
  2. executor.map 一次性提交;Pool.imap 惰性返回结果流。
  3. 项目初始化、模型加载通过 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,由采集器统一收集。

原理流程

  1. 各进程 handler 独立缓冲并持有文件偏移。
  2. 同时写入同一文件时字节交错或覆盖。
  3. 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。
  • 关闭顺序:先停流量,再停后台任务,最后关资源;反之会丢消息。

原理流程

  1. 信号处理函数只设置 Event 或标志位。
  2. 主循环检查标志后停止接收新任务。
  3. 等待在途任务在超时内完成,再关闭线程池、连接与文件。

代码或图示

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 是标准库调度器,单线程、无持久化,进程退出即丢。
  • 多实例部署必须做分布式锁/单例调度,否则任务重复执行。

原理流程

  1. 调度器按 cron/interval/date 规则触发任务。
  2. 单机调度在进程内线程/线程池执行;分布式由 Beat 投递到 Broker,Worker 消费执行。
  3. 失败重试、死信处理由任务框架保障。

代码或图示

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/数据库,接口只做“提交 + 查询”。

原理流程

  1. Web 进程接收请求,把任务投递到队列,立即返回 task_id。
  2. 独立 Worker 从队列消费、执行、写结果。
  3. 客户端轮询/回调查询任务状态。

代码或图示

@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。
  • 背压要可观测:队列长度、等待时长、拒绝计数。

原理流程

  1. 有界队列满时,生产者阻塞在 put,不再继续产生任务。
  2. 下游消费腾出空位后,生产者被唤醒继续。
  3. 无法阻塞时使用拒绝策略:返回 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 频繁切换。
  • 线程数暴涨:检查是否重复创建线程池、是否有未回收的线程。

原理流程

  1. 定时/手动导出所有线程栈,定位阻塞点。
  2. 多次采样对比栈位置不变,则偏向死锁;热点集中则偏向 CPU 忙等。
  3. 结合 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)或降级采样。

原理流程

  1. print 写内容与换行分多次系统调用,中间可被其他线程穿插。
  2. StreamHandler 内部加锁,单进程内单条记录完整。
  3. 多进程各自持锁互不感知,写入仍会覆盖。

代码或图示

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。
  • 计数器也可用“分片计数 + 汇总”减少争用。

原理流程

  1. Value/Array 在共享内存映射同一区域,进程直接读写。
  2. 读-改-写通过内部锁串行化。
  3. 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,可与其他线程并行。
  • 多进程 + 共享内存可避免大数据复制。

原理流程

  1. C 扩展在计算入口释放 GIL,计算期间其他线程可运行。
  2. 多进程由操作系统调度到不同核,各跑独立解释器。
  3. 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 在子线程中运行是常见模式(如后台常驻协程)。
  • 线程池任务不要回调协程对象,需显式调度回原循环。

原理流程

  1. 子线程内创建并运行独立事件循环。
  2. 主线程有循环时,用 run_coroutine_threadsafe 把协程投递到该循环。
  3. 协程内通过执行器把阻塞调用交给线程池。

代码或图示

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 并接受不一致。

概念解释

  • 本地缓存命中率高但多副本不一致,适合只读配置、字典类数据。
  • 进程重启会清空本地缓存,注意缓存雪崩。

原理流程

  1. 各进程独立建立连接池,连接不跨进程传递。
  2. 共享数据走外部缓存,本地 L1 只缓存热点只读项。
  3. 失效通过 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 密集应使用进程池而不是线程池。

原理流程

  1. 协程通过执行器把阻塞调用提交到线程池。
  2. 线程执行完成后把结果/异常交回循环,协程恢复。
  3. 线程内异常在 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 不高。发现方式:监控活跃线程数、队列等待时长、任务执行时长分布;修复:隔离池(快/慢任务分开)、限制单任务时长、扩容或异步化。

概念解释

  • 常见于“一个池跑所有任务”,慢任务(大文件、外部超时)拖住整池。
  • 用独立执行器隔离关键路径与后台任务。

原理流程

  1. 长任务长期占用池内线程,新任务在队列排队。
  2. 队列积压导致等待时长上升,CPU 却不高。
  3. 隔离快慢任务池、加任务超时与熔断,避免无限等待。

代码或图示

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 后的清理回调。

原理流程

  1. fork 复制父进程内存与文件描述符,但只留下调用 fork 的线程。
  2. 其他线程持有的锁处于已锁定状态,子进程无人释放。
  3. 事件循环内部 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 需自己实现。

原理流程

  1. multiprocessing 启动新解释器,按 pickle 协议传函数与参数。
  2. subprocess 创建外部进程,通过管道与其标准输入输出通信。
  3. 外部工具本身是瓶颈且不适合库化时,可用进程池包一层并发。

代码或图示

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 释放。
  • 测试中需提供可替换的池,避免真实线程。

原理流程

  1. 应用启动时创建一次池,存入全局/工厂对象。
  2. 请求处理从单例池借用任务执行。
  3. 应用停机时统一 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。
  • 压测数据要可复现:固定数据集、清缓存、记录版本与配置。

原理流程

  1. 定义吞吐、延迟分位、错误率等指标。
  2. 逐步加压,观察拐点特征:延迟非线性上升、错误率抬头、队列积压。
  3. 定位瓶颈层级,靠优化或扩容解决,按拐点容量留余量上线。

代码或图示

# 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)