Python 的全局解释器锁是什么

全局解释性锁，简称 GIL (Global Interpreter Lock)，它是什么，官方有如下解释：

In CPython, the global interpreter lock, or GIL, is a mutex that protects access to Python objects, preventing multiple threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.)

我们可以得出：

GIL 在执行 Python 字节码时保护访问 Python 对象而阻止多个线程执行的互斥锁，主要因为 CPython 的解释器非线程安全。
GIL 非 Python 语言特性，而是依赖于解释器的实现，CPython 实现了 GIL 机制
GIL 保证 Python 解释器运行时，同一时刻只有一个线程运行，保证内存管理安全
目前已经有许多功能依赖 GIL

常见的 Python 解释器有如下几种，以及这些解释器是否存在 GIL：

CPython：C 语言开发的解释器，默认官方版本，使用最为广泛，有 GIL
IPython：基于 CPython 开发的交互式解释器，只是增强了交互功能，执行功能与 CPython 完全一样
PyPy：目标是加快执行速度，采用 JIT 技术，对 Python 代码进行动态编译（不是解释），可显著提高执行速度，但执行结果可能与 CPython 不同。有 GIL，但其开发者宣布发布去掉 GIL 的版本
Jython：运行在 Java 平台上的 Python 解释器，可以把 Python 代码编译成 Java 字节码，依赖 Java 平台，没有 GIL
IronPython：和 Jython 类似，执行在微软 .Net 平台的 Python 解释器，可以把 Python 代码编译成 .Net 字节码依赖 .Net 平台，没有 GIL

GIL Problem:

import threading

def loop():
    count = 0
    while count <= 1000000000:
        count += 1

# 2 个线程执行 loop 方法 
t1 = threading.Thread (target=loop)
t2 = threading.Thread (target=loop)

t1.start ()
t2.start ()
t1.join ()
t2.join ()

上面这段代码，虽然开了 2 个线程执行，但我们观察 CPU 使用情况，发现其只能跑满一个核心。

由于 GIL 的存在，当线程被操作系统唤醒后，必须拿到 GIL 锁后才能执行代码，也就是说同一时刻永远只有一个线程在执行，这就导致如果我们的程序是 CPU 密集运算型的任务，那么使用 Python 多线程是不能提高效率的。

但即使有 GIL 的存在，理论来上来说，只要 GIL 释放的够勤快，多线程执行怎么也要比单线程效率高吧？

现实结果是：效率比我们想象的更糟糕！

串行执行 2 次 CPU 密集型任务：

import time
import threading

def loop ():
    count = 0
    while count <= 5000000000:
        count += 1


def main ():
    # 串行执行 2 次 CPU 密集型任务 
    start = time.time ()
    loop ()
    loop ()
    print time.time () - start

if __name__ == '__main__':
    main ()

# 540.302778006

2 个线程同时执行 CPU 密集型任务：

import time
import threading

def loop ():
    count = 0
    while count <= 5000000000:
        count += 1


def main ():
    # 2 个线程同时执行 CPU 密集型任务 
    start = time.time ()
    
    t1 = threading.Thread (target=loop)
    t2 = threading.Thread (target=loop)
    t1.start ()
    t2.start ()
    t1.join ()
    t2.join ()
    
    print time.time () - start

if __name__ == '__main__':
    main ()
    
# 573.972337961

上面的代码分别模拟了一个 CPU 密集型任务在串行执行 2 次和 2 个线程同时执行的场景，执行结果发现，多线程的效率还不如串行效率高！

为什么会导致这种情况？我们来分析其背后的工作原理。

How GIL?

由于 Python 的线程就是 C 语言的 pthread，它是通过操作系统调度算法调度执行。而 Python 的执行是基于 opcode 数量的调度方式，简单来说就是每执行一定数量的字节码，或遇到系统 IO 时，会强制释放 GIL，然后触发一次操作系统的线程调度。

单核 CPU 下的多线程

如果是单核 CPU 情况下，在多线程执行时，每次线程 A 释放 GIL 后，被唤醒的线程 B 能够立即拿到 GIL，能够无缝执行，执行流程如下图：

1524717396

多核 CPU 下的多线程

但在多核 CPU 情况下多线程执行时，一个线程在 CPU0 执行完之后释放 GIL，其他 CPU 上的线程都会进行竞争，但 CPU0 可能又马上获取到了 GIL，这就导致其他 CPU 上被唤醒的线程只能眼巴巴地看着 CPU0 上的线程欢快地执行着，而自己只能等待，直到又被切换到待调度的状态，这就会产生多核 CPU 频繁进行线程切换，消耗着资源，但只有一个线程能够拿到 GIL 真正执行 Python 代码，这就导致多线程在多核 CPU 情况下，效率还不如单线程执行效率高。执行流程如下图：

1524709489