Python 多线程与多进程的选择与实践-Python教程-PHP中文网

答案：Python中多线程适用于I/O密集型任务，因线程在I/O等待时释放GIL，提升并发效率；多进程适用于CPU密集型任务，可绕过GIL实现多核并行。选择时需根据任务类型、数据共享需求、通信开销和资源消耗综合权衡，混合模式可用于复杂场景，同时注意避免竞态条件、死锁、僵尸进程等陷阱，合理使用线程池或进程池优化性能。

python 多线程与多进程的选择与实践

在Python中，多线程和多进程的选择，说到底就是你面对的是I/O密集型任务还是CPU密集型任务。简单来说，如果你大部分时间在等待外部资源（比如网络请求、文件读写），多线程通常是更轻量、更合适的选择；而如果你的程序大部分时间都在进行复杂的计算，那么多进程才能真正发挥多核CPU的优势，实现并行计算。

解决方案

在我看来，理解Python并发的核心，首先要正视那个绕不开的“幽灵”——全局解释器锁（GIL）。它让Python的多线程在CPU密集型任务上显得有些“跛脚”，因为同一时刻只有一个线程能真正执行Python字节码。但这不是说多线程就一无是处，恰恰相反，在处理大量I/O等待时，比如爬虫、网络服务，线程在等待I/O时会释放GIL，允许其他线程运行，这效率提升是实实在在的。

而多进程，它完全绕过了GIL的限制，每个进程都有自己独立的Python解释器和内存空间。这意味着它们可以真正在不同的CPU核心上并行运行，对于那些需要大量数学计算、数据处理的场景，比如机器学习模型的训练、复杂的图像处理，多进程是当之无二的首选。

实际选择时，我通常会这样思考：

立即学习“Python免费学习笔记（深入）”；

任务类型判断：
- I/O密集型：涉及网络请求（HTTP、数据库）、文件操作、用户输入等待等。这时候，我会倾向于使用
```
threading
```
  登录后复制
  模块，或者更高级的
```
concurrent.futures.ThreadPoolExecutor
```
  登录后复制
  。它的上下文切换开销小，资源消耗也相对较少。
- CPU密集型：涉及大量循环计算、复杂算法、数据分析、加密解密等。这时，
```
multiprocessing
```
  登录后复制
  模块，或者
```
concurrent.futures.ProcessPoolExecutor
```
  登录后复制
  ，是我的不二之选。它能充分利用多核CPU，但进程间的通信和数据共享会复杂一些，开销也相对大。
数据共享与通信：
- 多线程：线程共享同一进程的内存空间，数据共享相对容易，但需要小心锁（
```
Lock
```
  登录后复制
  、
```
RLock
```
  登录后复制
  ）、信号量（
```
Semaphore
```
  登录后复制
  ）等同步机制，避免竞态条件和死锁。这部分往往是调试的重灾区，稍不留神就会引入难以发现的bug。
- 多进程：进程间内存独立，数据共享需要显式地通过队列（
```
Queue
```
  登录后复制
  ）、管道（
```
Pipe
```
  登录后复制
  ）、共享内存（
```
Value
```
  登录后复制
  、
```
Array
```
  登录后复制
  ）等方式进行。虽然增加了复杂性，但避免了GIL带来的同步问题，也降低了意外修改共享数据的风险。
启动开销：
- 线程的创建和销毁开销远小于进程。进程的创建需要复制父进程的内存空间（尽管现代操作系统有写时复制优化），这在启动大量进程时会显著增加开销。

在实践中，我发现很多时候任务并非纯粹的I/O或CPU密集型，它们往往是混合型的。这时，可以考虑“混合模式”：例如，用多进程来处理不同的数据集或任务批次，每个进程内部再用多线程来处理其I/O密集型子任务。

Python GIL究竟如何影响多线程性能？

我们谈到Python多线程，就必然会提到GIL。它不是Python语言的特性，而是CPython解释器的一种实现机制。它的核心作用是确保在任何给定时刻，只有一个线程可以执行Python字节码。这主要是为了简化内存管理和避免复杂的锁机制，使得C扩展的开发更为容易。

那么，这个GIL究竟是如何影响多线程性能的呢？最直观的冲击就是，对于纯粹的CPU密集型任务，无论你启动多少个线程，它们都无法真正地并行执行。它们会轮流获得GIL，执行一小段代码，然后释放，再由下一个线程获取。这就像一扇只有一个入口的旋转门，即使门外排了再多的人，也只能一个一个地通过。在某些极端情况下，频繁的上下文切换甚至可能导致多线程版本的CPU密集型程序比单线程版本还要慢，因为切换本身也是有开销的。

ECMall

ECMall 社区电子商务系统（简称 ECMall）是继 ECShop 之后推出的又一个电子商务姊妹产品。与 ECShop 不同的是，ECMall 是一个允许店铺加盟的多店系统。它不仅可以帮助众多成熟的网络社区实现社区电子商务还可以推进各种地域性、垂直性明显的门户网站的电子商务进程。ECMall 是一个根据融合了电子商务以及网络社区特色的产品，它不仅能使您的电子商务进程变得异常轻松，同时通过和康盛

查看详情

然而，对于I/O密集型任务，情况就大不相同了。当一个线程执行到I/O操作时（例如，发起网络请求、读取文件），它会主动释放GIL，允许其他线程获取GIL并执行CPU操作。当I/O操作完成后，该线程会再次尝试获取GIL。这种机制使得在等待外部资源时，其他线程能够充分利用CPU时间，从而提高了整体的吞吐量。我个人在处理大量网络请求时，往往会发现多线程带来的性能提升非常明显，尽管它们并非真正并行，但“并发”的效果却足以满足需求。理解这一点，对于我们在Python中设计并发程序至关重要，它决定了我们是否能正确地选择并发模型，避免不必要的性能瓶颈。

何时优先考虑Python多进程而非多线程？

优先考虑Python多进程的场景，核心在于“真并行”的需求。当你的任务是CPU密集型的，并且你希望充分利用现代多核处理器的计算能力时，多进程就是唯一的答案。

设想一个场景：你需要处理一个包含数百万条记录的大型数据集，对每一条记录执行复杂的统计分析或机器学习预测。如果使用多线程，即使你的机器有16个核心，GIL也会强制所有线程在单个核心上“排队”执行，导致其他核心闲置。而采用多进程，你可以将数据集分割成若干个子集，然后启动多个进程，每个进程处理一个子集。这样，每个进程都能在独立的CPU核心上运行其Python解释器，实现真正的并行计算，显著缩短总处理时间。

除了纯粹的CPU密集型计算，多进程在以下几种情况也显示出其独特的优势：

隔离性要求高：每个进程都有独立的内存空间，一个进程的崩溃不会直接影响到其他进程。这在构建健壮的系统时非常有用，比如一个服务需要处理多种类型的请求，某个请求的处理逻辑出现问题导致进程崩溃，其他请求的处理进程仍然可以正常运行。
需要避免GIL限制的库：有些Python库，特别是那些底层用C或Fortran编写的科学计算库（如NumPy、SciPy），在执行其核心计算时会释放GIL。这使得它们在多线程环境中也能实现一定程度的并行。但如果你的代码逻辑本身就是CPU密集型，或者你使用的库不释放GIL，那么多进程仍然是绕过GIL的最佳途径。
大规模数据并行处理：当数据可以被独立地分割和处理时，多进程模型非常适合。例如，图像处理任务中，可以把一张大图分成多个区域，每个进程处理一个区域。

当然，多进程也并非没有代价。进程创建的开销较大，进程间通信（IPC）也比线程间通信复杂，通常需要序列化和反序列化数据，这会引入额外的延迟。因此，在决定使用多进程时，需要权衡其带来的并行收益与额外的开销和复杂性。我通常会先尝试用单进程跑一遍，如果性能瓶颈明显在CPU上，并且任务可以自然地分解，那么我就会毫不犹豫地转向多进程。

Python多线程/多进程实践中的常见陷阱与优化策略

在Python中玩转并发，无论是多线程还是多进程，都会遇到一些“坑”。我个人在实践中，也踩过不少，这里总结一些常见的陷阱和对应的优化策略。

多线程的陷阱与策略：

竞态条件（Race Conditions）：这是多线程最经典的陷阱。多个线程同时访问和修改共享数据时，最终结果可能取决于线程执行的时序，导致不可预测的错误。
- 策略：使用锁（
```
threading.Lock
```
  登录后复制
  ）来保护临界区，确保同一时间只有一个线程访问共享资源。更高级的还有
```
RLock
```
  登录后复制
  （可重入锁）、
```
Semaphore
```
  登录后复制
  （信号量）来控制资源访问数量，或者
```
Condition
```
  登录后复制
  （条件变量）进行线程间的协调。不过，过度使用锁也可能导致性能下降甚至死锁。
死锁（Deadlock）：当两个或多个线程互相持有对方需要的锁，导致所有线程都无法继续执行时，就发生了死锁。
- 策略：尽量减少锁的持有时间。保持锁的获取顺序一致，例如，如果线程A和线程B都需要获取锁X和锁Y，那么它们都应该先获取X再获取Y。使用
```
timeout
```
  登录后复制
  参数尝试获取锁，避免无限等待。
GIL的误解：认为多线程可以加速CPU密集型任务。
- 策略：明确任务类型。对于CPU密集型，考虑多进程。对于I/O密集型，多线程通常有效。如果实在需要在多线程中执行CPU密集型操作，可以考虑将这部分逻辑用C/C++实现，并通过Python扩展调用，因为C/C++代码执行时可以释放GIL。

多进程的陷阱与策略：

进程间通信（IPC）开销：进程间数据不共享，需要通过队列、管道等机制传递数据，这涉及数据的序列化和反序列化，开销不小，尤其是在传递大量数据时。
- 策略：尽量减少进程间的数据传输量。只传递必要的数据，或者考虑使用共享内存（
```
multiprocessing.shared_memory
```
  登录后复制
  或
```
Value
```
  登录后复制
  /
```
Array
```
  登录后复制
  ）来共享大型数据结构，避免复制。对于复杂对象，可以考虑使用
```
pickle
```
  登录后复制
  进行高效序列化。
资源消耗：每个进程都有自己的内存空间和资源句柄，启动大量进程会消耗大量内存和CPU。
- 策略：使用进程池（
```
multiprocessing.Pool
```
  登录后复制
  或
```
concurrent.futures.ProcessPoolExecutor
```
  登录后复制
  ）来管理进程数量，避免创建过多进程。合理设置进程池大小，通常与CPU核心数相当或略多。
僵尸进程：如果父进程没有正确地等待子进程结束，子进程结束后会变成僵尸进程，占用系统资源。
- 策略：父进程需要调用
```
process.join()
```
  登录后复制
  方法等待子进程结束，或者将子进程设置为守护进程（
```
process.daemon = True
```
  登录后复制
  ），这样父进程退出时子进程也会自动退出。使用
```
ProcessPoolExecutor
```
  登录后复制
  时，这些管理通常由框架自动处理。

通用优化策略：

使用
concurrent.futures
登录后复制
模块：这是Python 3推荐的并发编程高级接口，它提供了
```
ThreadPoolExecutor
```
登录后复制
和
```
ProcessPoolExecutor
```
登录后复制
，极大地简化了线程池和进程池的管理，让代码更简洁、更易维护。我个人非常喜欢用它来处理并发任务，它抽象掉了许多底层细节。
任务分解与粒度：将大任务分解成独立、可并行的小任务。任务粒度要适中，过细会导致通信和管理开销过大，过粗则无法充分利用并发能力。
性能分析：不要凭感觉优化。使用
```
cProfile
```
登录后复制
、
```
timeit
```
登录后复制
等工具分析代码的瓶颈所在。对于并发程序，
```
htop
```
登录后复制
或任务管理器可以帮助你观察CPU利用率和内存消耗，判断是否真的实现了并行或并发。
避免全局状态：无论是多线程还是多进程，都尽量避免使用全局变量或可变全局状态。这会增加同步的复杂性，并引入难以调试的bug。如果确实需要共享状态，请使用队列、共享内存等明确的IPC机制。
日志记录：在并发程序中，清晰的日志对于调试至关重要。记录每个线程或进程的活动，包括它们何时开始、何时结束、处理了什么数据，以及可能遇到的错误。这能帮助你追踪问题发生的原因和时序。