python怎么实现多线程或多进程_python多线程与多进程编程入门-Python教程-PHP中文网

多线程适用于IO密集型任务，因GIL在IO等待时释放，可实现高效并发；多进程则通过独立解释器绕过GIL，适合CPU密集型任务实现真正并行，但存在内存开销大、IPC复杂等问题。

python怎么实现多线程或多进程_python多线程与多进程编程入门

在Python中，实现多线程主要依赖于内置的

threading

登录后复制

模块，而多进程则通过

multiprocessing

登录后复制

模块来完成。选择哪种方式，很大程度上取决于你面对的任务类型：如果你的程序大部分时间都在等待外部资源（比如网络请求、文件读写），那么多线程通常是更合适的选择；而如果你的程序需要大量计算，占用CPU资源，那么多进程则是突破Python全局解释器锁（GIL）限制，实现真正并行计算的关键。

解决方案

谈到Python的并发编程，这本身就是一个充满了权衡与抉择的领域。我个人在处理一些高并发或计算密集型任务时，常常在这两者之间摇摆。但最终的决策，往往是基于对任务特性和Python自身机制的深刻理解。

多线程：为IO密集型任务而生

当我们使用

threading

登录后复制

模块时，其实是在同一个进程内部创建了多个执行流。这些线程共享进程的内存空间，因此数据共享相对容易，但同时也带来了同步的复杂性。

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

一个基本的多线程例子是这样的：

import threading
import time

def task(name):
    print(f"线程 {name}: 启动")
    time.sleep(2) # 模拟IO操作，比如网络请求或文件读写
    print(f"线程 {name}: 完成")

if __name__ == "__main__":
    threads = []
    for i in range(3):
        thread = threading.Thread(target=task, args=(f"T-{i}",))
        threads.append(thread)
        thread.start() # 启动线程

    for thread in threads:
        thread.join() # 等待所有线程完成

    print("所有线程任务完成。")

登录后复制

这段代码中，

time.sleep(2)

登录后复制

模拟的就是一个IO阻塞操作。在这种情况下，尽管GIL依然存在，但当一个线程在等待IO时，GIL会被释放，允许其他线程运行。这使得多个IO操作可以“并发”进行，显著提升了程序的响应速度和效率。对于Web爬虫、异步API调用等场景，多线程无疑是一个简洁而有效的方案。

多进程：突破GIL，实现CPU密集型任务的并行

multiprocessing

登录后复制

模块则完全是另一回事。它通过创建独立的进程来绕过GIL的限制。每个进程都有自己独立的Python解释器和内存空间，这意味着它们可以真正地在多核CPU上并行执行。

下面是一个多进程的简单示例：

import multiprocessing
import time

def cpu_intensive_task(name):
    print(f"进程 {name}: 启动")
    result = 0
    for _ in range(1_000_000): # 模拟大量计算
        result += 1
    print(f"进程 {name}: 完成，结果为 {result}")
    return result

if __name__ == "__main__":
    processes = []
    for i in range(3):
        process = multiprocessing.Process(target=cpu_intensive_task, args=(f"P-{i}",))
        processes.append(process)
        process.start() # 启动进程

    for process in processes:
        process.join() # 等待所有进程完成

    print("所有进程任务完成。")

登录后复制

在这个例子里，

cpu_intensive_task

登录后复制

执行的是纯粹的CPU计算。如果用多线程来跑这样的任务，你会发现总耗时几乎和单线程一样，甚至更长（因为线程切换也有开销）。但多进程则能真正利用多核优势，让多个计算任务同时进行，大幅缩短总运行时间。当然，进程间通信（IPC）会比线程间通信复杂一些，通常需要借助

Queue

登录后复制

、

Pipe

登录后复制

或

Manager

登录后复制

等机制。

Python多线程真的能“并行”吗？深入理解GIL的限制与适用场景

这是一个我经常被问到的问题，也是很多Python初学者会感到困惑的地方。坦白说，对于纯Python代码，答案是“不能真正并行”。这里，我们必须提到Python的“全球解释器锁”（Global Interpreter Lock），简称GIL。

GIL是一个互斥锁，它保护着Python解释器，确保在任何时刻，只有一个线程能够执行Python字节码。这意味着，即使你的机器有16个CPU核心，当你在Python中运行多线程时，也只有一个核心在执行Python代码。其他的Python线程，即便它们“准备就绪”，也必须等待GIL被释放才能轮到它们。这听起来可能有点反直觉，甚至让人觉得Python的多线程是“假的”。

然而，这并不意味着多线程毫无用处。GIL在某些情况下会被释放，最典型的就是当线程执行I/O操作时。比如，当一个线程发起一个网络请求，或者在等待硬盘读写完成时，它会主动释放GIL。这样一来，其他Python线程就可以趁机获取GIL并执行它们的任务。这就是为什么多线程在处理IO密集型任务时表现出色：它利用了等待I/O的时间片，让多个任务看起来像是同时进行的。

豆包AI编程

豆包推出的AI编程助手

483

查看详情

想象一下，你有一组工人（线程），他们都需要使用一台打印机（Python解释器）。GIL就像是打印机旁的一个保安，一次只允许一个工人使用打印机。但是，如果一个工人去接电话（IO操作），保安就会让出打印机给下一个工人。所以，虽然没有两个工人能同时打印，但他们可以高效地轮流使用打印机，尤其是在打电话的工人等待时间很长的情况下。

所以，如果你正在编写一个需要频繁进行网络通信、数据库查询或文件操作的程序，多线程仍然是你的好朋友。它能有效提升程序的并发能力，而你无需为此付出进程创建和管理的高昂代价。但如果你的任务是密集的数学计算、图像处理或数据分析，那你就得考虑多进程了。

何时选择多进程？从CPU密集型任务看其优势与资源开销

在我看来，选择多进程通常是当你发现你的Python程序在单核上跑得飞快，但在多核上却无法充分利用所有核心时。这几乎是GIL在CPU密集型任务上施加的直接影响。

优势：

多进程最大的优势在于它能彻底绕开GIL。每个进程都有自己独立的内存空间和Python解释器实例。这意味着，当你启动多个进程时，它们可以真正地在多个CPU核心上并行执行Python字节码，实现真·并行。对于那些需要大量计算、数据处理、科学模拟等CPU密集型任务，多进程是提升性能的“银弹”。例如，我曾处理过一个需要对大量图像进行复杂算法处理的项目，一开始用多线程，性能提升微乎其微，后来切换到多进程，直接让处理时间缩短了数倍。

资源开销与挑战：

当然，这种并行能力并非没有代价。

内存消耗： 每个进程都需要加载一份Python解释器，并拥有自己独立的内存空间。这意味着与多线程相比，多进程会消耗更多的内存。如果你的程序已经很“吃内存”，再启动几十个进程可能会让你的系统不堪重负。
启动开销： 创建一个新进程比创建一个新线程要“重”得多。进程的创建涉及到操作系统的资源分配，因此启动时间会更长。对于那些需要频繁创建和销毁工作单元的短生命周期任务，多进程的开销可能会抵消并行带来的收益。
进程间通信（IPC）复杂性： 线程共享内存，可以直接访问共享变量（尽管需要锁来同步）。而进程之间是相互隔离的，它们不能直接访问彼此的内存。因此，进程间需要通过更复杂的机制进行通信，比如
```
Queue
```
登录后复制
（队列）、
```
Pipe
```
登录后复制
（管道）、
```
Value
```
登录后复制
/
```
Array
```
登录后复制
（共享内存）或者
```
Manager
```
登录后复制
（管理器）。这些IPC机制通常涉及到数据的序列化和反序列化，这本身也会带来额外的性能开销。
调试难度： 调试多个独立运行的进程通常比调试多线程更具挑战性。

尽管有这些开销，但对于那些核心瓶颈在于CPU计算的任务，多进程的优势是压倒性的。

multiprocessing.Pool

登录后复制

提供了一个更高级别的抽象，可以让你更方便地将任务分发给一个进程池去处理，这在很多情况下能大大简化代码。

多线程与多进程编程中的常见陷阱与调试技巧

在我的实践中，无论是多线程还是多进程，都会遇到一些令人头疼的问题。这些问题往往隐藏得很深，一旦出现，调试起来颇费周折。

常见陷阱：

竞态条件（Race Conditions）： 这是并发编程中最经典的问题之一。当多个线程或进程试图同时访问并修改同一个共享资源时，最终结果可能依赖于它们执行的相对顺序，导致不可预测的错误。比如，两个线程同时对一个计数器进行
```
+1
```
登录后复制
操作，如果没有加锁，最终结果可能不是
```
+2
```
登录后复制
。
- 解决方案： 使用锁（
```
threading.Lock
```
  登录后复制
  或
```
multiprocessing.Lock
```
  登录后复制
  ）来保护共享资源的访问。更高级的同步原语如信号量（
```
Semaphore
```
  登录后复制
  ）、条件变量（
```
Condition
```
  登录后复制
  ）也很有用。对于进程间通信，通常使用
```
Queue
```
  登录后复制
  或
```
Pipe
```
  登录后复制
  来避免直接共享状态。
死锁（Deadlock）： 当两个或多个线程（或进程）互相持有对方需要的资源，并且都在等待对方释放资源时，就会发生死锁。它们会无限期地阻塞下去。这就像两个人各拿着一把钥匙，但需要对方的钥匙才能打开自己的门，结果谁也进不去。
- 解决方案： 仔细设计资源获取的顺序，确保所有线程都以相同的顺序获取锁。使用带超时的锁（
```
acquire(timeout=...)
```
  登录后复制
  ）可以帮助检测和避免永久性死锁。
数据共享的复杂性：
- 线程： 虽然线程共享内存使得数据共享直观，但如果没有适当的同步机制，共享可变数据会非常危险。
- 进程： 进程间的数据共享需要明确的IPC机制。直接传递大量数据可能导致性能瓶颈（序列化/反序列化）。如果数据量大，考虑使用共享内存（
```
multiprocessing.Value
```
  登录后复制
  或
```
Array
```
  登录后复制
  ）或
```
Manager
```
  登录后复制
  来管理共享对象。
守护线程/进程（Daemon Threads/Processes）： 默认情况下，如果主线程/进程退出，非守护线程/进程会继续运行直到完成。但如果设置为守护线程/进程（
```
thread.daemon = True
```
登录后复制
或
```
process.daemon = True
```
登录后复制
），它们会在主程序退出时被强制终止，这可能导致数据丢失或资源未正确释放。
- 解决方案： 确保所有重要的子线程/进程在主程序退出前都调用了
```
join()
```
  登录后复制
  方法，等待它们正常结束。
资源泄漏： 在多线程/多进程环境中，文件句柄、数据库连接、网络套接字等资源如果没有正确关闭，可能会导致系统资源耗尽。
- 解决方案： 总是使用
```
with
```
  登录后复制
  语句来管理资源，或者在
```
finally
```
  登录后复制
  块中确保资源被关闭。

调试技巧：

并发编程的调试是出了名的困难，因为错误往往是非确定性的，难以重现。

日志记录（Logging）： 这是我最常用的方法。在关键代码路径上添加详细的日志输出，包括线程/进程ID、时间戳、变量状态等。这能帮助你追踪执行流，理解事件发生的顺序。Python的
```
logging
```
登录后复制
模块非常强大，可以配置不同的日志级别和输出目标。
减少并发度： 当出现问题时，尝试将并发度降低到最小（比如只运行两个线程或进程），这有助于简化问题，更容易复现和定位。
使用调试器（pdb）： Python自带的
```
pdb
```
登录后复制
调试器可以在多线程/多进程环境中工作，但需要一些技巧。你可以尝试在子线程/进程中插入
```
pdb.set_trace()
```
登录后复制
，但这可能会导致其他线程/进程继续运行，使得调试变得复杂。更稳妥的做法是，在主进程中启动调试，然后逐步跟踪。对于多进程，可能需要独立地启动和调试每个进程。
条件断点： 在某些特定条件（比如某个变量达到特定值）下才触发的断点，对于定位竞态条件或特定状态下的错误非常有效。
隔离问题： 如果可能，将并发逻辑与业务逻辑分离，单独测试并发部分，确保其正确性。
善用
Queue
登录后复制
：在多进程中，
```
Queue
```
登录后复制
不仅是通信工具，也可以作为一种调试手段。你可以将中间结果、状态信息甚至错误信息放入队列，由主进程统一收集和打印，避免多个进程同时向控制台输出造成混乱。