关于 Python 的 import，你了解多少？

多线程和多进程是 Python 中两种实现多任务的不同策略，二者都可以在特定的场景下在一定程度上提高程序的运行速度、性能以及吞吐，但二者的运行机制却有很大的差别。

在 Python 中，多线程以_并发（concurrent）的方式运行，适用于 I/O 密集型任务的场景；多进程以并行（parallelism）的方式运行，适用于计算密集型_任务的场景。虽然多进程也可以用于 I/O 密集型任务的场景，但这会导致部分 CPU 性能的浪费，且进程的开销也比线程要高。而多线程用于计算密集型的任务场景则相当于这些任务串行执行。

⒈ GIL（Global Interpreter Lock）

⑴ GIL 介绍

GIL 是一种互斥锁机制，其目的是为了确保在同一时间只有一个线程可以运行，进而确保了在同一时间只有一个线程可以访问/操作内存。但这同时也阻止了 Python 多线程对多核处理器的充分利用。

⑵ 为什么引入 GIL

Python 通过引用计数的方式进行垃圾回收。当一个对象的引用计数降为 0 时，该对象会被垃圾回收，其所占用的内存空间会被释放。

import sysa = []
b = a
print(sys.getrefcount(a)) # 3

上例中，对象 [] 被变量 a、b 以及函数 sys.getrefcount() 的参数同时引用，故结果为 3

如果允许同一时间有多个线程同时运行，那么这些线程同时修改对象的引用计数可能会出现竞争条件，最终导致对象的引用计数错误，进而导致程序崩溃（引用计数过早的降为 0）或内存泄漏。

import threadingcount = 0def accumulator():global countfor i in range(0, 100000):count += 1threads = []for i in range(0, 100):threads.append(threading.Thread(target=accumulator))for thread in threads:thread.start()for thread in threads:thread.join()print(count) # 8752687

GIL 只是确保同一时间只有一个线程在执行，但并不一定能阻止竞争条件

⑶ GIL 带来的影响

GIL 使得 Python 多线程无法充分利用多核处理器的优势，进而使得多线程无法适用于计算密集型的场景。

GIL 可能会在 Python 3.13 中设置为可选项

⒉ 多线程

在 Python 中，由于 GIL 机制的限制，同一时间只能有一个线程在执行，这就决定了 Python 的多线程只会对 I/O 密集型任务的性能有显著的提升。

在 I/O 密集型的任务场景中，当一个线程因为等待 I/O 被阻塞时，系统可以将当前线程挂起而执行其他线程，这样可以充分利用 CPU 资源，缩短程序的总体运行时间，提升性能。

from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
import matplotlib.pyplot as plt
from random import choice
from string import ascii_letters
import timedef multi_threading(func, args, workers):with ThreadPoolExecutor(max_workers=workers) as ex:res = ex.map(func, args)return list(res)def create_text():text = ''.join(choice(ascii_letters) for i in range(10**7))return textdef io_bound(text: str, base: float = 0):start = time.time() - basef = open('letters.txt', 'wt', encoding='utf-8')f.write(text)end = time.time() - basereturn start, enddef visualize_performance(times: list, workers: list):figure, axe = plt.subplots(layout='constrained')figure.suptitle('io bound tasks: more threads, less time')axe.set_xlabel('number of threads')axe.set_ylabel("time used (s)")axe.bar(workers, times)plt.show()texts = [create_text() for i in range(16)]
workers_num = [1, 2, 4, 8, 16]
times = []
for num in workers_num:start = time.time()res = multi_threading(io_bound, texts, num)end = time.time()times.append(end - start)visualize_performance(times, ['1', '2', '4', '8', '16'])

上述代码通过将一个随机生成的包含 10710^7107 个字符的字符串写入文本文件 16 次来模拟 I/O 密集型任务的场景。在程序运行过程中，整体的运行时间会随着线程数量的增加而下降。

def multi_threading(func, args, workers):start_time = time.time()with ThreadPoolExecutor(max_workers=workers) as ex:res = ex.map(func, args, [start_time] * len(args))return list(res)def visualize_mechanism(times: list, task_num: int):figure, axe = plt.subplots(layout='constrained')figure.suptitle('io bound tasks with %s threads' % task_num)axe.set_xlabel('seconds')axe.set_ylabel('tasks')widths = [t[1] - t[0] for t in times]lefts = [t[0] for t in times]axe.barh(range(len(times)), widths, left=lefts)plt.show()texts = [create_text() for i in range(16)]
workers_num = [1, 2, 4, 8, 16]
times = []for num in workers_num:res = multi_threading(io_bound, texts, num)visualize_mechanism(res, num)

对之前的代码进行适当的修改，查看多线程的运行机制。当只有一个线程来执行上述文件写入操作时，所有的 16 次文件写入会依次执行，每一次写入都只有等到上一次写入彻底完成后才能开始执行。

而在多线程模式下，上述的文件写入操作则会并发执行。

对于计算密集型的任务，随着线程数量的增加，任务的执行速度和性能并没有提升。

def cpu_bound(base: float = 0):start = time.time() - basecount = 0for i in range(0, 10**5):count += 1end = time.time() - basereturn start, end

⒊ 多进程

Python 中的多进程充分利用了多核处理器的优势，使得多任务可以并行执行。并行执行的任务数越多，程序运行的越快。Python 多进程模式下，每个进程都有各自独立的解释器（interpreter），各个进程的内存空间也相互独立，所以 GIL 机制并不会成为多进程的瓶颈。

from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
import matplotlib.pyplot as plt
from random import choice
from string import ascii_letters
import time
from math import cos, pidef multi_processing(func, workers):with ProcessPoolExecutor(max_workers=workers) as ex:res = ex.map(func, [0] * 16)return list(res)def cpu_bound(base: float = 0):start = time.time() - basecount = 0for i in range(0, 10**5):count += cos(i * pi)end = time.time() - basereturn start, endworkers_num = [1, 2, 4, 8, 16]
times = []for num in workers_num:start = time.time()res = multi_processing(cpu_bound, num)end = time.time()times.append(end - start)visualize_performance(times, ['1', '2', '4', '8', '16'])

上述代码通过进行 16 次大量数学计算模拟计算密集型任务场景。随着进程数量的增加，刚开始程序的运行会越来越快。但当进程数量超过机器内核数量时（4），程序运行反而会因为进程的切换而变慢。