从Python的GIL谈谈Python多线程和多进程

Python 的全局解释器锁（Global Interpreter Lock，GIL）

1. 什么是 GIL？

全局解释器锁（GIL）是 CPython（Python 最常用的解释器实现）中为了实现线程安全而引入的一种机制。
它是一个互斥锁（Mutex），保证在任意时刻，进程中只有一个线程可以执行 Python 的字节码。

换句话说，尽管 Python 支持多线程编程，但由于 GIL 的存在，同一个Python 进程内的多线程无法真正实现多核 CPU 的并行计算。同一个进程中所有线程在执行时都需要获得 GIL，未获得 GIL 的线程会被阻塞。

2. 为什么需要 GIL？

GIL 的引入是为了简化 CPython 的内存管理。
Python 使用 引用计数（Reference Counting） 机制来管理内存，如果没有 GIL，多个线程同时操作一个对象的引用计数可能会导致数据竞争，从而引发内存错误。
通过 GIL 的存在，CPython 避免了这些复杂的多线程同步问题。

例如：

# 多线程操作同一个对象的引用计数
x = 42
# 线程1：增加引用计数
# 线程2：同时减少引用计数

如果没有 GIL，可能会导致对象的引用计数出现竞态条件，最终内存管理失效。

3. GIL 的影响

• 对多线程的限制：在多核 CPU 上，GIL 限制了 Python 程序的性能，导致线程之间不能并行执行 CPU 密集型任务。
• 对 I/O 密集型任务影响较小：对于 I/O 密集型任务（如网络请求、文件操作），线程在等待 I/O 时会释放 GIL，因此多线程仍然可以提高性能。
• 多进程的替代方案：多进程不受 GIL 限制，因为每个进程都有独立的 GIL，可以并行运行。

4. GIL 的释放和切换

1）GIL 的释放：

• 当一个线程执行耗时较长的 I/O 操作时（如 time.sleep() 或 socket.recv()），线程会主动释放 GIL。
• C 扩展模块可以手动释放 GIL，例如 numpy 等计算库在执行底层计算时会释放 GIL，从而提高性能。

2）GIL 的切换：

• Python 在多线程中，会定期切换 GIL 以让其他线程有机会运行。
• 切换频率由 sys.setswitchinterval() 控制，默认值约为 5 毫秒。

5. 实例：GIL 的影响

CPU 密集型任务：多线程无法提升性能。

import threading
import time

def cpu_task():
    count = 0
    for _ in range(10**7):
        count += 1

start = time.time()
threads = [threading.Thread(target=cpu_task) for _ in range(4)]
for t in threads:
    t.start()
for t in threads:
    t.join()
end = time.time()

print(f"Total time: {end - start:.2f} seconds")

结果： 即使开启多个线程，运行时间不会显著缩短，原因是 GIL 限制了线程的并行。

I/O 密集型任务：多线程可以显著提升性能。

import threading
import time

def io_task():
    time.sleep(2)

start = time.time()
threads = [threading.Thread(target=io_task) for _ in range(4)]
for t in threads:
    t.start()
for t in threads:
    t.join()
end = time.time()

print(f"Total time: {end - start:.2f} seconds")

结果： 多线程能够显著减少 I/O 密集型任务的总耗时，因为线程会在等待 I/O 时释放 GIL。

6. 如何绕过 GIL 的限制？

1）使用多进程：

• 多进程不受 GIL 限制，每个进程有自己的 GIL，适合 CPU 密集型任务。
• 示例：

from multiprocessing import Process

def cpu_task():
    count = 0
    for _ in range(10**7):
        count += 1

processes = [Process(target=cpu_task) for _ in range(4)]
for p in processes:
    p.start()
for p in processes:
    p.join()

2）使用 C 扩展库：

• 一些科学计算库（如 numpy）会在底层计算中释放 GIL，从而提升性能。
• 示例：

import numpy as np
x = np.random.random((1000, 1000))
result = np.dot(x, x)  # 内部释放 GIL

3）使用 JIT 编译器（如 PyPy）：

• PyPy 是一个替代 Python 解释器，它在某些情况下不使用 GIL。

7. 总结

• GIL 是 CPython 的线程安全机制，但它限制了多线程在 CPU 密集型任务中的性能。
• 对于 I/O 密集型任务，多线程仍然有效。
• 对于 CPU 密集型任务，建议使用多进程或其他绕过 GIL 的方法。
• 了解 GIL 的限制和释放机制，可以帮助我们更高效地编写 Python 并发程序。

Python的多线程和多进程

Python 中的多线程是解决并发问题的工具，但是由于GIL的存在，Python又引入了多进程，这里就详细的介绍一下Python的多线程和多进程。

1. Python 多线程

1）什么是多线程？

多线程是一种并发执行的方式，它允许一个进程中同时运行多个线程，每个线程共享同一个内存空间。

2）Python 多线程的特点

• 全局解释器锁（GIL）：Python 的 GIL 限制了同一时刻只有一个线程在执行 Python 字节码。因此，在 CPU 密集型任务中，多线程并不能带来性能提升。
• 适合 I/O 密集型任务：对于文件操作、网络请求等需要等待外部资源的任务，多线程可以有效减少等待时间。

3）多线程代码实例

以下是一个使用多线程加速网络请求的例子：

import threading
import time
import requests

def fetch_url(url):
    print(f"Fetching {url}...")
    response = requests.get(url)
    print(f"Finished {url}: {response.status_code}")

urls = [
    "https://www.baidu.com",
    "https://www.w3school.com.cn/",
    "https://www.python.org",
]

start = time.time()

# 创建线程
threads = [threading.Thread(target=fetch_url, args=(url,)) for url in urls]

# 启动线程
for thread in threads:
    thread.start()

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

print(f"Total time: {time.time() - start:.2f} seconds")

输出： 多个 URL 被并发抓取，总耗时比串行执行显著减少。

4）适用场景

• 文件 I/O 操作
• 网络爬虫
• 数据库查询

2. Python 多进程

1）什么是多进程？

多进程是指在操作系统中运行多个独立的进程。每个进程都有独立的内存空间，因此多进程不受 GIL 的限制。

2）Python 多进程的特点

• 独立性：每个进程有自己独立的内存空间。
• 开销较大：创建进程需要较高的系统开销，进程之间的通信成本较高。
• 适合 CPU 密集型任务：多进程可以充分利用多核 CPU 提升性能。

3）多进程代码实例

以下是一个多进程计算大数组平方和的例子：

import multiprocessing
import time

def compute_square(numbers, result, index):
    print(f"Process {index} calculating squares...")
    for idx, n in enumerate(numbers):
        result[index] += n ** 2
    print(f"Process {index} done.")

if __name__ == "__main__":
    numbers = [i for i in range(1, 10000001)]  # 1 到 1000 万
    num_processes = 4
    chunk_size = len(numbers) // num_processes
    manager = multiprocessing.Manager()
    result = manager.list([0] * num_processes)

    processes = []
    start = time.time()

    # 创建进程
    for i in range(num_processes):
        chunk = numbers[i * chunk_size:(i + 1) * chunk_size]
        p = multiprocessing.Process(target=compute_square, args=(chunk, result, i))
        processes.append(p)
        p.start()

    # 等待进程完成
    for p in processes:
        p.join()

    total_sum = sum(result)
    print(f"Total sum of squares: {total_sum}")
    print(f"Total time: {time.time() - start:.2f} seconds")

输出： 分块计算后，多进程完成任务的速度远快于单进程。

4）适用场景

• 数值计算
• 图像处理
• 大数据分析

3. 多线程与多进程的比较

4. 选择多线程还是多进程？

1）使用多线程

• 网络请求优化（如 Web 爬虫）。
• 文件读写操作。
• 数据库 I/O。

2） 使用多进程

• 数值计算（如矩阵运算）。
• 图像处理（如图片批量编辑）。
• 大型数据处理。

5. 实战场景对比

场景1：I/O 密集型任务

任务描述：爬取多个网页并保存内容。

多线程：

import threading
import requests

urls = ["https://www.example.com"] * 100

def fetch(url):
    requests.get(url)

threads = [threading.Thread(target=fetch, args=(url,)) for url in urls]
for t in threads: t.start()
for t in threads: t.join()

多进程：

import multiprocessing
import requests

urls = ["https://www.example.com"] * 100

def fetch(url):
    requests.get(url)

with multiprocessing.Pool(4) as pool:
    pool.map(fetch, urls)

结果：

• 多线程因 GIL 限制和 I/O 等待时间，可以高效运行。
• 多进程在这种场景下开销较大，反而可能更慢。

场景2：CPU 密集型任务

任务描述：对大数组进行复杂计算。

多线程： 受 GIL 限制，无法利用多核 CPU。

多进程： 每个进程独立运行，充分利用多核 CPU，性能提升显著。

6. 总结

• 多线程适合 I/O 密集型任务，例如文件读写、网络请求。
• 多进程适合 CPU 密集型任务，例如数值计算、图像处理。
• Python 的 GIL 是选择并发模型时的重要考虑因素。
• 开发时应根据任务特点合理选择多线程或多进程。

通过多线程和多进程的灵活使用，我们可以显著提升程序的并发能力与性能。合理选择适用方案，能够为项目带来最佳的效率收益。