Python 为什么只用了一个 CPU
在现代计算机中，拥有多个 CPU 或多核处理器已经是常态。然而，许多 Python 开发者发现，Python 的多线程性能并不如预期。让我们来深入探讨 Python 为什么在执行多线程时常常只使用一个 CPU 核心。
1. GIL（全局解释器锁）
1.1 什么是 GIL？
GIL（Global Interpreter Lock，全球解释器锁）是 CPython（Python 的官方实现）中的一个机制。它作用于 Python 解释器，确保同一时间只有一个线程可以执行 Python 字节码。虽然这可以简化内存管理和其他内部机制，但也意味着多线程程序在 CPU 计算密集型任务中的性能不会提高。
1.2 GIL 的影响
由于 GIL 的存在，即使在多核 CPU 系统中，当多个线程尝试执行 Python 代码时，只有一个线程能真正运行。这导致了 CPU 的资源无法得到充分利用。
1.3 示例代码
下面的代码展示了 Python 线程在 GIL 下的行为。我们将创建多个线程同时执行计算任务。
import threading
import time
def compute_square(n):
print(f"Thread {n} is starting.")
start_time = time.time()
sum = 0
for i in range(10**6):
sum += i * i
end_time = time.time()
print(f"Thread {n} completed in {end_time - start_time:.2f} seconds.")
threads = []
for i in range(4):
t = threading.Thread(target=compute_square, args=(i,))
threads.append(t)
t.start()
for t in threads:
t.join()
在这个示例中，我们创建了四个线程来计算平方和。由于 GIL 的存在，这些线程的执行并不会真正并行，效率反而可能低于单线程运行。
2. CPU 计算与 I/O 操作的区别
2.1 CPU 密集型与 I/O 密集型
我们可以将程序的计算任务分为两类：CPU 密集型和 I/O 密集型。
- CPU 密集型：这些任务涉及大量的计算，例如数学运算、图像处理等。
- I/O 密集型：这些任务通常涉及读写文件、网络通信等操作，徒劳地等待外部设备的响应。
对于 I/O 密集型任务，Python 的多线程可以有效利用，因为线程可以在等待 I/O 完成时让出 GIL，但对于 CPU 密集型任务，多线程往往不会带来性能提升。
2.2 示例代码
我们可以通过下面的代码来对比 CPU 密集型和 I/O 密集型任务的表现。
import threading
import time
# I/O 密集型任务
def io_bound_task(n):
print(f"Starting I/O task {n}.")
time.sleep(2)
print(f"Completed I/O task {n}.")
# CPU 密集型任务
def cpu_bound_task(n):
print(f"Starting CPU task {n}.")
sum = 0
for _ in range(10**6):
sum += 1
print(f"Completed CPU task {n}.")
threads = []
for i in range(4):
t_io = threading.Thread(target=io_bound_task, args=(i,))
threads.append(t_io)
t_io.start()
for t in threads:
t.join()
# CPU 密集型任务测试
cpu_threads = []
for i in range(4):
t_cpu = threading.Thread(target=cpu_bound_task, args=(i,))
cpu_threads.append(t_cpu)
t_cpu.start()
for t in cpu_threads:
t.join()
通过对比这两个示例，你会发现 I/O 密集型的任务表现会更好。而对于 CPU 密集型的任务，所有线程的执行时间可能接近。
3. 如何在 Python 中利用多核 CPU？
尽管 Python 的多线程受限于 GIL，但我们仍然可以通过其他方式充分利用多核 CPU，比如使用 multiprocessing 模块。这个模块允许我们创建多个独立的进程，这些进程可以并行运行，并且每个进程都有自己的 Python 解释器和 GIL。
3.1 示例代码
import multiprocessing
import time
def compute_square(n):
print(f"Process {n} is starting.")
start_time = time.time()
sum = 0
for i in range(10**6):
sum += i * i
end_time = time.time()
print(f"Process {n} completed in {end_time - start_time:.2f} seconds.")
if __name__ == "__main__":
processes = []
for i in range(4):
p = multiprocessing.Process(target=compute_square, args=(i,))
processes.append(p)
p.start()
for p in processes:
p.join()
在这个示例中，我们使用 multiprocessing 来创建进程，每个进程可以独立执行无需担心 GIL 的限制。这种方法可以显著改善 CPU 密集型任务的性能。
4. 结论
Python 的 GIL 限制了多线程的并发性能，因此在 CPU 密集型任务中，Python 通常只会利用一个 CPU 核心。然而，通过 multiprocessing 模块和其他异步编程模型，我们仍然可以充分利用计算机的多核能力。理解 GIL 的影响，将帮助我们选择合适的工具和技术，更高效地编写 Python 程序。
在开发过程中，选择适当的并发模型可以极大优化性能。当面对不同类型的任务时，需要灵活运用 Python 提供的多线程与多进程机制，来实现最佳的性能表现。
