面试题：Python多线程与多进程选择策略之GIL影响及应用场景

Question

Python的全局解释器锁（GIL）对多线程和多进程有怎样不同的影响？请举例说明在哪些计算密集型场景下，即使存在GIL，多线程仍有一定的应用价值，以及如何利用多进程来规避GIL带来的性能瓶颈。

Answer 1

GIL对多线程和多进程的不同影响

1. 多线程：
   • 影响：GIL会导致同一时刻只有一个线程能在CPU上执行，即使在多核CPU环境下，Python多线程也无法真正利用多核优势进行并行计算。这是因为GIL会在每个线程执行时获取，释放GIL通常是在I/O操作、时间片结束等情况下。例如，在计算密集型任务中，线程不断执行计算操作，GIL被一个线程长时间持有，其他线程只能等待，无法并行执行，使得多线程不能提升计算速度，甚至因为线程切换开销而变慢。
   • 示例：

import threading
import time


def cpu_bound_task():
    result = 0
    for i in range(100000000):
        result += i
    return result


start_time = time.time()
threads = []
for _ in range(4):
    t = threading.Thread(target=cpu_bound_task)
    threads.append(t)
    t.start()
for t in threads:
    t.join()
end_time = time.time()
print(f"多线程执行时间: {end_time - start_time}秒")


start_time = time.time()
cpu_bound_task()
cpu_bound_task()
cpu_bound_task()
cpu_bound_task()
end_time = time.time()
print(f"单线程执行时间: {end_time - start_time}秒")

在这个例子中，多线程执行计算密集型任务并没有比单线程快，反而因为线程切换开销可能更慢。 2. 多进程：

• 影响：每个进程都有自己独立的Python解释器和内存空间，不存在GIL问题。每个进程可以在不同的CPU核心上并行执行，真正利用多核CPU的优势，适合计算密集型任务。
• 示例：

import multiprocessing
import time


def cpu_bound_task():
    result = 0
    for i in range(100000000):
        result += i
    return result


start_time = time.time()
processes = []
for _ in range(4):
    p = multiprocessing.Process(target=cpu_bound_task)
    processes.append(p)
    p.start()
for p in processes:
    p.join()
end_time = time.time()
print(f"多进程执行时间: {end_time - start_time}秒")

在这个例子中，多进程可以利用多核CPU并行执行计算密集型任务，大幅提升执行速度。

计算密集型场景下多线程仍有应用价值的情况

1. 场景：当计算任务中存在大量的I/O操作时，多线程有一定应用价值。因为在执行I/O操作时，线程会释放GIL，其他线程可以获取GIL并执行。例如，在爬虫程序中，线程在等待网络响应（I/O操作）时，GIL被释放，其他线程可以继续执行，从而提高整体效率。
2. 示例：

import threading
import requests


def io_bound_task(url):
    response = requests.get(url)
    return response.status_code


urls = [
    'https://www.example.com',
    'https://www.google.com',
    'https://www.baidu.com'
]
start_time = time.time()
threads = []
for url in urls:
    t = threading.Thread(target=io_bound_task, args=(url,))
    threads.append(t)
    t.start()
for t in threads:
    t.join()
end_time = time.time()
print(f"多线程执行I/O任务时间: {end_time - start_time}秒")


start_time = time.time()
for url in urls:
    io_bound_task(url)
end_time = time.time()
print(f"单线程执行I/O任务时间: {end_time - start_time}秒")

在这个例子中，多线程执行I/O密集型任务比单线程快，因为在I/O等待时GIL被释放，其他线程可以执行。

利用多进程规避GIL带来的性能瓶颈

1. 方法：使用multiprocessing模块创建进程。如上述计算密集型任务的多进程示例，将任务分配到多个进程中执行。可以根据CPU核心数来合理设置进程数量，充分利用多核CPU资源。例如：

import multiprocessing


def cpu_bound_task():
    result = 0
    for i in range(100000000):
        result += i
    return result


if __name__ == '__main__':
    num_processes = multiprocessing.cpu_count()
    pool = multiprocessing.Pool(processes=num_processes)
    results = pool.map(cpu_bound_task, range(num_processes))
    pool.close()
    pool.join()
    print(results)

在这个例子中，通过multiprocessing.Pool创建进程池，map方法将任务分配到各个进程并行执行，有效规避了GIL带来的性能瓶颈。同时，在Windows系统下运行多进程代码时，需要将相关代码放在if __name__ == '__main__':语句块中，以避免一些运行时错误。