Python 中用线程执行阻塞式 I/O，不做并行计算

Python 中用线程执行阻塞式 I/O，不做并行计算

尽管 Python 也支持多线程，但这些线程受 GIL（global interpreter lock，全局解释器锁） 约束，所以每次或许只能有一条线程向前推进，而无法实现多头并进。既然有这么多限制，那 Python 还支持多线程干什么？

首先，这种机制让我们很容易就能实现出一种效果，也就是令人感觉程序似乎能在同一时间做许多件事。这样的效果采用手工方式很难编写​，而通过线程来实现，则可以让 Python 自动替我们把这些问题处理好，让多项任务能够并发地执行。

其次，可以通过 Python 的多线程机制处理阻塞式的 I/O 任务，因为线程在执行某些系统调用的过程中会发生阻塞，假如只支持一条线程，那么整个程序就会卡在这里不动。Python 程序需要通过系统调用与外部环境交互，其中有一些调用属于阻塞式的 I/O 操作，例如读取文件、写入文件、联网以及与显示器等设备交互。多线程机制可以让程序中的其他线程继续执行各自的工作，只有发起调用请求的那条线程才需要卡在那里等待操作系统给出结果。

1.看一看用线程做并行计算。

例如，要用 Python 程序执行一批计算量很大的任务。以最原始的办法实现这样一个因数分解算法，以模拟这种任务。

def factorize(number):
    for i in range(1, number + 1):
        if number % i == 0:
            yield i

试着分解几个数。如果必须把上一个数分解完才能开始分解下一个数，那么程序花的时间就比较长。

import time

def factorize(number):
    for i in range(1, number + 1):
        if number % i == 0:
            yield i

numbers = [2139079, 1214759, 1516637, 1852285]
start = time.time()

for number in numbers:
    list(factorize(number))

end = time.time()
delta = end - start
print(f'Took {delta:.3f} seconds')

# >>>
# Took 0.266 seconds

让每条线程各自分解一个数或许可以把计算机中的多个 CPU 核心充分利用起来。这种想法对于其他语言来说，可能有些道理，但是在 Python 中效果如何呢？试着定义这样一种 Python 线程，让它完成与刚才相同的因数分解任务。

from threading import Thread

class FactorizeThread(Thread):
    def __init__(self, number):
        super().__init__()
        self.number = number

    def run(self):
        self.factors = list(factorize(self.number))

然后，针对每个待分解的数字都启动这样一条线程，让它们平行地运行下去。

start = time.time()

threads = []
for number in numbers:
    thread = FactorizeThread(number)
    thread.start()
    threads.append(thread)

最后，等待所有线程执行完毕。

for thread in threads:
    thread.join()

end = time.time()
delta = end - start
print(f'Took {delta:.3f} seconds')

# >>>
# Took 0.277 seconds

奇怪的是，这样做竟然比一个一个去分解还要慢，没有把多核心的优势发挥出来。理论上像这样令 4 条线程分别执行各自的任务，应该比一条线程连续执行 4 份任务要快得多。这是因为，这种多线程的程序在标准的 CPython 解释器之中会受 GIL 牵制，例如 CPython 要通过 GIL 防止这些线程争抢全局锁，而且要花一些时间来协调。

2.再来看一看用线程执行阻塞式 I/O。

例如，要通过串口（serial port）向遥控直升机发送信号。以 select 这个系统调用来模拟这项操作。通过 select 函数让操作系统阻塞 0.1 秒，然后把控制权返还给本程序，这样就模拟出了使用串口通信的效果。

import select
import socket

def slow_systemcall():
    select.select([socket.socket()], [], [], 0.1)

通过这种方式依次执行系统调用，程序的执行时间会随着调用次数而上升。

start = time.time()

for _ in range(5):
    slow_systemcall()

end = time.time()
delta = end - start
print(f'Took {delta:.3f} seconds')

# >>>
# Took 0.541 seconds

这样写有个问题，就是程序在执行 slow_systemcall 函数的过程中会彻底卡住，因为它的主线程会阻塞在 select 这里。在实际的程序里面，这是个相当糟糕的现象，因为向直升机发送信号的同时，还需要计算接下来的移动方式，不然直升机就会坠毁。所以，如果在执行阻塞式 I/O 的过程中还需要做计算，那么应该把系统调用放到另一条线程执行。下面把 slow_systemcall 放在单独的线程里调用，这样能同时触发多项操作，于是可以在与多个串口（乃至多个直升机）通信的同时，在主线程里做其他必要的运算。

start = time.time()
threads = []
for _ in range(5):
    thread = Thread(target=slow_systemcall)
    thread.start()
    threads.append(thread)

将 5 条线程启动之后，主线程可以先去计算直升机接下来的移动方式，然后再去等待那 5 条线程把各自的系统调用执行完毕。

def compute_helicopter_location(index):
    ...

for i in range(5):
    compute_helicopter_location(i)

for thread in threads:
    thread.join()

end = time.time()
delta = end - start
print(f'Took {delta:.3f} seconds')

# >>>
# Took 0.109 seconds

与依次执行系统调用的那种写法相比，这种写法的速度几乎能达到原来的 5 倍。这说明，尽管那 5 条线程依然受 GIL 制约，但它们所发起的系统调用是可以各自向前执行的。GIL 只不过是让 Python 内部的代码无法平行推进而已，至于系统调用，则不会受到影响，因为 Python 线程在即将执行系统调用时，会释放 GIL，待完成调用之后，才会重新获取它。

用多线程处理阻塞式 I/O 是最简单的，多条 Python 线程可以并行地执行多个系统调用，这样就能让程序在执行阻塞式的 I/O 任务时，继续做其他运算。