Python语言的标准实现叫作CPython,它分两步来运行Python程序。首先解析源代码文本,并将其编译成字节码(bytecode)。字节码是一种底层代码,可以把程序表示成8位的指令(从Python 3.6开始,这种底层代码实际上已经变成16位了,所以应该叫作wordcode才对,但基本原理依然相同)。然后,CPython采用基于栈的解释器来运行字节码。这种字节码解释器在执行Python程序的过程中,必须确保相关的状态不受干扰,所以CPython会用一种叫作全局解释器锁(global interpreter lock,GIL)的机制来保证这一点。

GIL实际上就是一种互斥锁(mutual-exclusion lock,mutex),用来防止CPython的状态在抢占式的多线程环境(preemptive multithreading)之中受到干扰,因为在这种环境下,一条线程有可能突然打断另一条线程抢占程序的控制权。如果这种抢占行为来得不是时候,那么解释器的状态(例如为垃圾回收工作而设立的引用计数等)就会遭到破坏。所以,CPython要通过GIL阻止这样的动作,以确保它自身以及它的那些C扩展模块能够正确地执行每一条字节码指令。
但是,GIL会产生一个很不好的影响。在C++与Java这样的语言里面,如果程序之中有多个线程能够分头执行任务,那么就可以把CPU的各个核心充分地利用起来。尽管Python也支持多线程,但这些线程受GIL约束,所以每次或许只能有一条线程向前推进,而无法实现多头并进。所以,想通过多线程做并行计算或是给程序提速的开发者,恐怕要失望了。

我们用一段计算量很大的任务来看一下python在用多线程执行计算密集型任务时的表现。

# 因数分解算法
def factorize(number):
    for i in range(1,number+1):
        if number %i==0:
            yield i

import time

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')

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)

# thread.join()方法的作用是等待线程完成。当你启动一个线程后,这个线程会异步执行。如果你希望主线程(通常是执行thread.start()的线程)等待这个新线程完成其任务后再继续执行,你就需要调用thread.join()。
# 如果不调用thread.join(),主线程可能会在其他线程完成之前继续执行,这可能导致一些不可预测的行为或资源访问冲突,特别是当多个线程需要访问共享资源时。通过调用join(),你确保了主线程会等待每个工作线程完成其执行,从而实现线程间的同步。
for thread in threads:
    thread.join()

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

Output:

Took 0.179 seconds
Took 0.158 seconds

我们看结果,多线程并没有比单线程快很多。

下面我们看个IO密集型的任务。

import select
import socket
import time
from threading import Thread

#select.select,这是一个系统调用,用于监视文件描述符集合的变化情况。具体来说,select 函数可以监视三种类型的文件描述符集合:
#可读集合(readfds):等待数据变得可读(例如,网络套接字上有数据可读)的文件描述符集合。
#可写集合(writefds):等待数据变得可写(例如,套接字缓冲区有足够的空间可以发送数据)的文件描述符集合。
#异常集合(exceptfds):等待异常情况(如带外数据到达)的文件描述符集合。
#select.select 函数的最后一个参数是一个超时值,表示 select 函数等待事件发生的最长时间。在这个例子中,超时值被设置为 0.1 秒,这意味着 select 会在 0.1 秒后超时,无论是否有事件发生。
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')

start = time.time()

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

# 用此函数来模拟在执行系统调用时,我们还同时在做其他的事情
def compute_helicopter_location(index):
    print('Running compute helicopter location ')

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')

Output:

Took 0.517 seconds
Running compute helicopter location 
Running compute helicopter location 
Running compute helicopter location 
Running compute helicopter location 
Running compute helicopter location 
Took 0.108 seconds

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

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