python-GIL

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等概念的理解