GIL全域性直譯器鎖

global interpreter lock

鎖就是為了避免資源競爭造成資料的錯亂

1.啟動直譯器程序　　python.exe

2.解析你的py檔案並執行它

每個py程式中都必須有直譯器參與，直譯器其實就是一堆**，相當多執行緒要呼叫同乙個解釋**，共享就是競爭。競爭就要出事，所以需要要給直譯器加上直譯器。

python中記憶體管理依賴於gc（一段用於**記憶體的**）也是乙個執行緒。除了你自己開的執行緒，系統還有一些內建執行緒。就算你的**不會競爭直譯器，內建執行緒也可能會競爭，所以必須加上鎖。

當乙個執行緒遇到了io操作，同時直譯器也會自動解鎖，去執行其他執行緒cpu會切換到其他程式。

直譯器加鎖以後：

將導致所有執行緒只能開發，不能達到真正的並行，意味著同一時間只有乙個cpu在處理你的執行緒所以給你的感覺是效率低。

**執行有兩種狀態

阻塞io 失去cpu的執行權(cpu 等待io完成）

非阻塞 **正常執行，比如迴圈一千萬次，中途cpu可能切換，很快就會回來（cpu在計算）

如果你的**中io操作非常多，cpu效能不能直接絕對決定你的任務處理速度。

io密集程式

import

time ,os
from multiprocessing import
process
from threading import
thread,current_thread
deftask():
time.sleep(3)
deftask1():
time.sleep(3)
deftask2():
time.sleep(3)
deftask3():
time.sleep(3)
deftask4():
time.sleep(3)
deftask5():
time.sleep(3)
if__name__ == '
__main__':
start =time.time()
#多程序處理io密集程式 耗時3.6272077560424805
#p = process(target=task)
#p1 = process(target=task1)
#p2 = process(target=task2)
#p3 = process(target=task3)
#p4 = process(target=task4)
#p5 = process(target=task5)
#多執行緒處理io密集程式 耗時3.001171588897705（3秒是io固定長度）
p = thread(target=task)
p1 = thread(target=task1)
p2 = thread(target=task2)
p3 = thread(target=task3)
p4 = thread(target=task4)
p5 = thread(target=task5)
p.start()
p1.start()
p2.start()
p3.start()
p4.start()
p5.start()
p.join()
p1.join()
p2.join()
p3.join()
p4.join()
p5.join()
print(time.time()-start)

計算密集型程式

from multiprocessing import

process
from threading import
thread
import
time
deftask1():
sum =0
for i in range(10000000):
sum +=i
deftask2():
sum =0
for i in range(10000000):
sum +=i
deftask3():
sum =0
for i in range(10000000):
sum +=i
deftask4():
sum =0
for i in range(10000000):
sum +=i
deftask5():
sum =0
for i in range(10000000):
sum +=i
if__name__ == '
__main__':
#多程序處理運算密集型程式 2.9081664085388184
start =time.time()
#t1 = process(target=task1)
#t2 = process(target=task2)
#t3 = process(target=task3)
#t4 = process(target=task4)
#t5 = process(target=task5)
#多執行緒處理運算密集型程式 4.190239667892456
t1 = thread(target=task1)
t2 = thread(target=task2)
t3 = thread(target=task3)
t4 = thread(target=task4)
t5 = thread(target=task5)
t1.start()
t2.start()
t3.start()
t4.start()
t5.start()
t1.join()
t2.join()
t3.join()
t4.join()
t5.join()
print(time.time()-start)

在計算密集程式中使用多程序處理效率更高

在io操作密集的程式中使用多執行緒處理效率更加高

GIL 全域性直譯器鎖

1 描述python中gil的概念，以及它對python多執行緒的影響？編寫乙個多執行緒抓取網頁的程式，並闡明多執行緒抓取程式是否可比單執行緒效能有提公升，並解釋原因。答 gil global interpreter lock，即全域性直譯器鎖 1 python語言和gil沒有半毛錢關係。僅僅是由於...

GIL全域性直譯器鎖

gil 啥？他是如何產生的？gil產生的背景 在cpython解釋內部執行多個執行緒的時候，每個執行緒都需要直譯器內部申請相應的全域性資源，由於c語言本身比較底層造成cpython在管理所有全域性資源的時候並不能應對所有執行緒同時的資源請求，因此為了防止資源競爭而發生錯誤，對所有執行緒申請全域性資源...

全域性直譯器鎖GIL

我們使用高併發，一次是建立1萬個執行緒去修改乙個數並列印結果看現象 from threading import thread import osdef func args global n n args print n,os.getpid n 100t list for i in range 100...