python-GIL

系统 543 0

python线程之GIL

python的线程bug:GIL: Global Interpreter Lock 全局解释器锁

Python --> 支持多线程 --> 同步互斥 --> 加锁 --> 超级锁(把解释器锁住了)
--> 在同一时刻,解释器只能解释一个线程 --> 由于 历史原因,大量的python库延用了这种方法
--> 导致python多线程效率低下


GIL问题: 由于pythond 的全局解释器锁造成python的多线程效率低下

解决方法:
1, 不使用线程,使用多进程
2, 不使用C/c++ 做解释器;用C# java做解释器
3, Python多线程适合高用时的IO操作,如网络IO;不适合CPU密集型程序


GIL带来的影响:
多进程效率 > 单进程效率 > 多线程效率

代码案例,延时CPU密集型程序和IO密集型程序对单进程,多进程,多线程的耗时测试:

            
              #!/usr/bin/python3
#coding:utf-8

from time import time,sleep
from threading import Thread
from multiprocessing import Process


#cpu开销函数,计算15000W次
def cpu_cost(x, y):
    count = 1
    for _ in range(5000000):
        count += 1
        x += 1
        y += 1


#自定义IO开销函数,进行10W次写,100W次读操作
def io_cost():
    f = open('/tmp/test.log', 'w')
    for I in range(100000):
        f.write('Hello Python.')
    f.close()
    f = open('/tmp/test.log', 'r')
    for I in range(1000000):
        f.readline()
    f.close()


#单进程cpu密集型
def single_cpu():

    t1 = time()
    for _ in range(10):
        cpu_cost(1,1)
    t2 = time()
    print('单进程CPU密集型耗时:',t2 - t1)
    sleep(2)


#单进程IO密集型
def single_io():
    t1 = time()
    for _ in range(10):
        io_cost()

    t2 = time()
    print('单进程IO密集型耗时:',t2 - t1)
    sleep(2)


#多进程CPU密集型
def mul_process_cpu():
    t1 = time()
    process_lst = []

    for I in range(10):
        p = Process(target=cpu_cost, args = (1,1))
        p.start()

    for I in process_lst:
        I.join()
    t2 = time()
    print('多进程CPU密集型耗时:',t2 - t1)
    sleep(2)


#多进程IO密集型
def mul_process_io():
    t1 = time()
    process_lst = []
    for I in range(10):
        p = Process(target=io_cost)
        process_lst.append(p)
        p.start()

    for I in process_lst:
        I.join()
    t2 = time()
    print('多进程IO密集型耗时:',t2 - t1)
    sleep(2)


#多线程CPU密集型
def mul_thread_cpu():
    t1 = time()
    t_lst = []
    for _ in range(10):
        t = Thread(target=cpu_cost, args=(1,1))
        t_lst.append(t)
        t.start()

    for J in t_lst:
        J.join()
    t2 = time()
    print('多线程CPU密集型耗时:',t2 - t1)
    sleep(2)


#多线程IO密集型
def mul_thread_io():
    t1 =time()
    t_lst = []
    for _ in range(10):
        t = Thread(target=io_cost)
        t_lst.append(t)
        t.start()
    for J in t_lst:
        J.join()
    t2 = time()
    print('多线程IO密集型耗时:',t2 - t1)


#主程序
def main():
    single_cpu()
    single_io()
    mul_process_cpu()
    mul_process_io()
    mul_thread_cpu()
    mul_thread_io()

main()
            
          

执行结果:

            
              [root@A02-R05-I18-13-A003335 data]# python3 test.py 
单进程CPU密集型耗时: 7.388684272766113
单进程IO密集型耗时: 25.975133419036865
多进程CPU密集型耗时: 0.006726264953613281
多进程IO密集型耗时: 2.7583560943603516
多线程CPU密集型耗时: 7.976577043533325
多线程IO密集型耗时: 47.74693512916565
            
          

执行结果可以看出,Python中,多进程在高CPU和高IO情况下均是最优,其次是单进程但线程;多线程性能最差

 

设计模式
代表了一种最佳时间,是被开发 人员长期总结用来解决某一劳累问题的思路方法,这些方法保证了代码的效率也易于理解
逻辑编码模型

总结:
1, 进程和线程的区别和联系
2, 同步互斥的意义和实现方法
3, 进程线程使用什么方式通信
4,进程线程的特点和选择
5, 简单的设计模式和理解
6, 将是京城,进程状态,GIL等概念的理解


 


更多文章、技术交流、商务合作、联系博主

微信扫码或搜索:z360901061

微信扫一扫加我为好友

QQ号联系: 360901061

您的支持是博主写作最大的动力,如果您喜欢我的文章,感觉我的文章对您有帮助,请请扫描上面二维码支持博主1元、2元、5元等您想捐的金额吧,狠狠点击下面给点支持吧

发表我的评论
最新评论 总共0条评论