Python GIL

最新推荐文章于 2024-09-20 08:35:50 发布

stevewongbuaa

最新推荐文章于 2024-09-20 08:35:50 发布

阅读量545

点赞数

分类专栏： python 文章标签： Python

python 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

GIL(Global Interpreter Lock)

参考

UnderstandingGIL
Python的GIL是什么鬼，多线程性能究竟如何
 JesseFang Python GIL
python 线程，GIL 和 ctypes
mutex与semaphore的区别
 What is a mutex?

引文

GIL不是Python的特性，是在实现Python解释器CPython时所引入的一个概念。JPython就没有GIL。

官方解释

In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native 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.)
防止多线程并发执行机器码的一个mutex。全局排他锁。

只有获得了这个锁，才有在python解释器上执行python代码的权利。由于历史的原因这个锁的粒度太大了。

历史遗留原因

为了利用多核，Python开始支持多线程。而解决多线程之间数据完整性和状态同步的最简单方法自然就是加锁。

影响

全局锁的存在会对多线程的效率有不小的影响。几乎等于Python是个单线程的程序。

实验

使用一个循环一亿次的计数器函数。一个通过单线程执行2次，一个多线程执行。最后比较执行总时间。为了减少线程库本身性能损耗对测试结果带来的影响，这里单线程的代码同样使用了线程。只是顺序的执行两次，模拟单线程。

单线程

# singleThread.py
from threading import Thread
import time

def my_counter():
    i = 0
    for _ in range(100000000):
        i = i + 1
    return True

def main():
    thread_array = {}
    start_time = time.time()
    for tid in range(2):
        t = Thread(target=my_counter)
        t.start()
        t.join()
    end_time = time.time()
    print("Total time: {}".format(end_time - start_time))

if __name__ == '__main__':
    main()

Total time: 19.9634678364

多线程

# mutiThread.py
from threading import Thread
import time

def my_counter():
    i = 0
    for _ in range(100000000):
        i = i + 1
    return True

def main():
    thread_array = {}
    start_time = time.time()
    for tid in range(2):
        t = Thread(target=my_counter)
        t.start()
        thread_array[tid] = t
    for i in range(2):
        thread_array[i].join()
    end_time = time.time()
    print("Total time: {}".format(end_time - start_time))

if __name__ == '__main__':
    main()

Total time: 34.3221170902

GIL设计缺陷

使用操作系统本身的线程调度。通过操作系统调度算法进行调度。为了让各个线程能够平均利用CPU时间，Python会计算当前已执行的微代码数量，达到一定阈值后强制释放GIL。而这时也会触发一次操作系统的线程调度（当然是否真正进行上下文切换由操作系统自主决定）。

CPython进程作为一个整体，同一时间只会有一个获得了GIL的线程在跑，其他的线程都处于等待状态等着GIL的释放。因为GIL的限制，两个线程只是做着分时切换。

这种模式在只有一个CPU核心的情况下毫无问题。任何一个线程被唤起时都能成功获得GIL（因为只有释放了GIL才会引发线程调度）。但当CPU有多个核心时，问题就来了。从释放锁到获得锁几乎是没有间隙的。所以当其他在其他核心上的线程被唤醒时，大部分情况下主线程已经再一次获取到GIL了。这个时候被唤醒执行的线程只能白白的浪费CPU时间，看着另一个线程拿着GIL欢快的执行着。然后达到切换时间后进入待调度状态，再被唤醒，再等待，如此往复恶性循环。

每次线程释放控制权后，其立马进入等待状态。而在多核情况下，往往由于拥有者比其它CPU运行的线程醒的更早，也就是自己释放后，立马自己又获得了。而其它CPU上运行的线程被唤醒时，发现锁还是被别人占着，空欢喜一场，无奈只能继续休眠等待。

IO密集型线程能否从多线程中受益呢？