python中的多线程和GIL

ゝ一纸荒年。 2023-03-13 13:15 44阅读 0赞

*GIL 是python的全局解释器锁，同一进程中假如有多个线程运行，一个线程在运行python程序的时候会霸占python解释器（加了一把锁即GIL），使该进程内的其他线程无法运行。*

在刚了解python中的GIL时，很多小伙伴应该和我一样，不明白既然GIL为进程上了一把锁，使进程内的其他线程无法运行，python中为什么还有多线程的概念？还有在多线程中再加锁？

其实，在python中，并不是等待一个线程结束之后再执行另外一个线程。举个例子，两个线程分别对一个全局变量total进行加和减。

total = 0
    def add(name):
        global total
        for i in range(100):
            total += 1
            print('当前是%s线程,i的值为%s' % (name,total))
    
    def desc(name):
        global total
        for i in range(100):
            total -= 1
            print('当前是%s线程,i的值为%s' % (name,total))
    
    import threading
    thread1 = threading.Thread(target=add,args=('thread1',))
    thread2 = threading.Thread(target=desc,args=('thread2',))
    
    thread1.start()
    thread2.start()
    
    thread1.join()
    thread2.join()
    
    print(total)

结果是  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNzkwMTU2MQ_size_16_color_FFFFFF_t_70_pic_center]  
从输出中我们可以看到，并不是等thread1线程执行完再执行thread2线程任务的。

***在GIL中，全局所并不是一直锁定的，在线程进行耗时的操作的时候，能会释放GIL。***

在CPU密集操作线程中，python的多线程并不会达到并发的效果，不如使用多进程。这里直接借用的一张[测试结果图][Link 1]（见下图）。图中表示的是两个线程在双核CPU上得执行情况。两个线程均为CPU密集型运算线程。绿色部分表示该线程在运行，且在执行有用的计算，红色部分为线程被调度唤醒，但是无法获取GIL导致无法进行有效运算等待的时间。由图可见，GIL的存在导致多线程无法很好的立即多核CPU的并发处理能力。  
![在这里插入图片描述][20200514015807764.png_pic_center]

在IO密集操作线程中，python的多线程还是很快的。比如在网络通信，time.sleep()延时的时候。举个例子，在多线程中，让每个线程休眠10秒。

def sleep_1():
    # 休眠10秒
        for _ in range(100):
            time.sleep(0.1)
    
    def test_thread():
        time1 = time.time()
        t1 = threading.Thread(target=sleep_1)
        t2 = threading.Thread(target=sleep_1)
        t3 = threading.Thread(target=sleep_1)
        t4 = threading.Thread(target=sleep_1)
        t1.start()
        t2.start()
        t3.start()
        t4.start()
        
        t1.join()
        t2.join()
        t3.join()
        t4.join()
        
        time2 = time.time()
        print("所有线程完成，运行时间为",time2-time1)
    if __name__ == '__main__':
        test_thread()

结果为  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNzkwMTU2MQ_size_16_color_FFFFFF_t_70_pic_center 1]

# 总结： #

1.  Python中一个线程并不会从头到尾占用GIL。当一个线程遇到I/O任务时，将释放GIL。计算密集型（CPU-bound）的线程在执行大约100次解释器的计步（ticks）时，将释放GIL。
2.  在CPU密集操作线程中，python的多线程并不会达到并发的效果，不如使用多进程。比如处理计算的时候。
3.  在IO密集操作线程中，python的多线程还是很快的。比如在网络通信，time.sleep()延时的时候。

--------------------

参考：  
[Python的GIL是什么鬼，多线程性能究竟如何][Python_GIL]  
[\[python\] GIL全局解释器锁][python_ GIL]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNzkwMTU2MQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20230312/dabdfe3bb6a94097b064cfc882f51e69.png
[Link 1]: http://dabeaz.blogspot.com/2010/01/python-gil-visualized.html
[20200514015807764.png_pic_center]: https://img-blog.csdnimg.cn/20200514015807764.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNzkwMTU2MQ_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20200514015515304.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNzkwMTU2MQ==,size_16,color_FFFFFF,t_70#pic_center
[Python_GIL]: http://cenalulu.github.io/python/gil-in-python/
[python_ GIL]: https://www.jianshu.com/p/ce31d1fdd302