如何使用Python的多线程与多进程：并发编程指南

天天向上

发布： 2025-01-12 10:12:48

原创

893 人浏览过

Python 的并发编程可以通过多线程（threading）和多进程（multiprocessing）来实现，这两种方法各有优缺点，适用于不同的场景。理解如何使用这些工具进行并发编程是提升 Python 性能的一个重要步骤，特别是在需要处理大量 I/O 操作或计算密集型任务时。

本文将深入探讨 Python 中的多线程与多进程，介绍它们的使用场景、优势、实现方式及注意事项。

一、理解多线程与多进程

多线程：

多线程是一种通过在单个进程内创建多个线程来实现并发的方式。每个线程在进程中共享内存空间，因此线程之间可以轻松地共享数据。
由于 Python 的全局解释器锁（GIL，Global Interpreter Lock），多线程并不能在 CPU 密集型任务中提高性能，但在 I/O 密集型任务中可以显著提高效率。

多进程：

多进程是在多个进程之间实现并行执行，每个进程有独立的内存空间。多进程可以绕过 GIL，因此适用于计算密集型任务。
每个进程独立执行，进程间通信需要使用队列或管道。

二、使用 Python 的多线程

1. 基础用法：`threading` 模块

threading 模块提供了多线程编程的基本功能。在 Python 中，线程的生命周期由 Thread 类管理。

示例：创建并启动多个线程

import threading
import time

# 线程执行的函数
def print_numbers():
    for i in range(5):
        print(i)
        time.sleep(1)  # 模拟耗时操作

# 创建线程
thread1 = threading.Thread(target=print_numbers)
thread2 = threading.Thread(target=print_numbers)

# 启动线程
thread1.start()
thread2.start()

# 等待线程完成
thread1.join()
thread2.join()

print("Threads have finished.")

在这个例子中，我们创建了两个线程来执行 print_numbers 函数，并使用 start() 方法启动它们，最后使用 join() 等待两个线程执行完成。

2. 使用线程池：`concurrent.futures` 模块

对于任务数量较多时，可以使用 concurrent.futures.ThreadPoolExecutor 来简化线程池的管理。

from concurrent.futures import ThreadPoolExecutor
import time

# 线程执行的函数
def print_numbers(i):
    print(f"Thread {i} is running")
    time.sleep(1)
    print(f"Thread {i} has finished")

# 使用线程池执行任务
with ThreadPoolExecutor(max_workers=3) as executor:
    for i in range(5):
        executor.submit(print_numbers, i)

在这个例子中，ThreadPoolExecutor 会自动管理多个线程，并且限制最大并发线程数为 3。

3. 注意事项：GIL 的影响

由于 Python 的 GIL，多个线程无法真正实现 CPU 密集型任务的并行计算。因此，多线程更适用于 I/O 密集型任务，比如文件 I/O、网络请求等。

三、使用 Python 的多进程

1. 基础用法：`multiprocessing` 模块

multiprocessing 模块提供了多进程编程的基本功能，适用于 CPU 密集型任务。

示例：创建并启动多个进程

import multiprocessing
import time

# 进程执行的函数
def print_numbers():
    for i in range(5):
        print(i)
        time.sleep(1)

# 创建进程
process1 = multiprocessing.Process(target=print_numbers)
process2 = multiprocessing.Process(target=print_numbers)

# 启动进程
process1.start()
process2.start()

# 等待进程完成
process1.join()
process2.join()

print("Processes have finished.")

在这个例子中，我们使用 multiprocessing.Process 类创建了两个进程并启动它们。每个进程独立执行 print_numbers 函数，彼此之间没有共享内存。

2. 使用进程池：`multiprocessing.Pool`

与 ThreadPoolExecutor 类似，multiprocessing 模块也提供了 Pool 类来管理多个进程。

import multiprocessing
import time

# 进程执行的函数
def print_numbers(i):
    print(f"Process {i} is running")
    time.sleep(1)
    print(f"Process {i} has finished")

# 使用进程池执行任务
if __name__ == "__main__":  # 在 Windows 上需要加这行
    with multiprocessing.Pool(processes=3) as pool:
        pool.map(print_numbers, range(5))

在这个例子中，Pool 用于管理进程池，map() 方法会将任务分配给池中的进程。

3. 进程间通信：`Queue` 和 `Pipe`

由于进程之间没有共享内存，必须使用进程间通信（IPC）来交换数据。multiprocessing 提供了 Queue 和 Pipe 用于进程间通信。

import multiprocessing

def send_data(queue):
    queue.put("Hello from Process")

def receive_data(queue):
    data = queue.get()
    print(f"Received: {data}")

if __name__ == "__main__":
    queue = multiprocessing.Queue()

    process1 = multiprocessing.Process(target=send_data, args=(queue,))
    process2 = multiprocessing.Process(target=receive_data, args=(queue,))

    process1.start()
    process2.start()

    process1.join()
    process2.join()

在这个例子中，Queue 被用来在两个进程之间传递数据。

四、如何选择多线程与多进程

多线程：

适合：I/O 密集型任务，如文件 I/O、网络请求等。
不适合：CPU 密集型任务，因为 GIL 限制了多线程的并行性。

多进程：

适合：CPU 密集型任务，可以绕过 GIL，充分利用多核处理器。
不适合：需要大量共享内存的数据交换，因为进程之间没有共享内存，进程间通信较为复杂且开销较大。

五、总结

Python 提供了多线程和多进程两种方式来实现并发编程，使用时需要根据任务的性质选择合适的方式。
多线程 适合 I/O 密集型任务，但受 GIL 的影响，无法提升 CPU 密集型任务的性能。
多进程 可以有效提升 CPU 密集型任务的性能，尤其在多核 CPU 上，可以并行处理多个任务。
在并发编程中，进程间通信和资源管理是需要特别注意的，Queue 和 Pipe 等工具可以帮助解决进程间数据交换的问题。

掌握 Python 的并发编程能够帮助你在处理大量任务时提升程序效率，但务必选择合适的工具并处理好并发过程中常见的复杂性。

一、理解多线程与多进程

二、使用 Python 的多线程

1. 基础用法：threading 模块

2. 使用线程池：concurrent.futures 模块