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

?