gilpython

① python gil 是線程安全的嗎

GIL完全可以不在意，根本不是問題。 GIL是Python的全局鎖，也就是有它在，同一時刻，只能一個線程訪問一個全局資源。 所以Python的多線程，完全沒辦法利用多核CPU。

② python gil為什麼還使用多線程

GIL 的作用是：對於一個解釋器，只能有一個thread在執行bytecode。所以每時每刻只有一條bytecode在被執行一個thread。GIL保證了bytecode 這層面上是thread safe的。

但是如果你有個操作比如 x += 1，這個操作需要多個bytecodes操作，在執行這個操作的多條bytecodes期間的時候可能中途就換thread了，這樣就出現了data races的情況了。

比如這小傢伙就有很多條bytecodes：
>>> dis.dis(lambda x: x+1)
1 0 LOAD_FAST 0 (x)
3 LOAD_CONST 1 (1)
6 BINARY_ADD
7 RETURN_VALUE

③ 為什麼說python性能差

python性能差具體原因如下：
1、python是動態語言
一個變數所指向對象的類型在運行時才確定，編譯器做不了任何預測，也就無從優化。
2、python是解釋執行，但是不支持JIT（just in time compiler）。雖然大名鼎鼎的google曾經嘗試Unladen Swallow 這個項目，但最終也折了。
3、python中一切都是對象，每個對象都需要維護引用計數，增加了額外的工作。
4、python GIL
GIL是Python最為詬病的一點，因為GIL，python中的多線程並不能真正的並發。
5、垃圾回收，這個可能是所有具有垃圾回收的編程語言的通病。
python採用標記和分代的垃圾回收策略，每次垃圾回收的時候都會中斷正在執行的程序，造成所謂的頓卡。

④ python為什麼適合大數據

因為方便啊。
在大數據面前，用什麼語言開發，執行起來都需要很長時間，都是慢。
那麼，執行速度方面已經沒有意義了，寫起來舒服的好處就凸顯出來了。
試想一下，對於一個大數據任務，你用C寫的程序要跑兩個小時，別人用python寫的要跑四個小時，沒人會盯首屏幕兩個小時，所以一般都會晚上下班時開始跑，第二天早上來看結果。那麼，對於一個晚上的時間來說，兩個小時和四個小時，是沒有差別的，第二天早上你都一樣可以看到結果。
在這種情況下，python的方便靈活就比C的艱深晦澀有吸引力了。

⑤ python GIL 和 線程鎖是不是同一個東西

今天看到一篇文章，講述的是幾個提升python性能的項目:傳送門

在看的過程中，接觸到一個名詞，一個從學python開始就一直看到，但是從來都是一知半解的名詞，心裡不開心，必須把它搞明白，對了，這個詞就是 GIL。網上搜索了一些資料，粗淺的理解了什麼是GIL，自己感覺學習的過程比較好，感覺略有收獲，老規矩，為了鞏固知識，自己整片文章出來寫一寫，其實好多文章已經寫的很完善了，所以這篇隨筆，只做知識鞏固，如有雷同，請各位原創作者原諒，小菜鳥一枚，如果哪裡寫的有問題，還請各位前輩不吝指正。

一句話：解決多線程之間數據完整性和狀態同步的最簡單方法自然就是加鎖。

首先，GIL的全名，Global Interpreter Lock，鑒於英文水平，不做名詞翻譯，以免誤導。大體解釋一下，這個鎖就是用來為了解決Cpython多線程中線程不安全問題引入的一個全局排它鎖，它的作用就是在多線程情況下，保護共享資源，為了不讓多個線程同時操作共享資源，導致不可預期的結果而加上的鎖，在一個線程操作共享資源時，其他線程請求該資源，只能等待GIL解鎖。這個設置在Cpython剛引入多線程概念的時候就有了，然後後續的各種包和組件開發都不可避免的受到了GIL的影響，所以有人會說，python在多線程處理的時候很慢。python GIL實現方式類似於如下偽代碼：

if __name__ == '__main__':
GIL鎖開始運作
主線程做操作
主線程完成操作
GIL鎖釋放資源

所以多線程共同操作共享資源的時候，有一個線程競得了資源，它就被GIL鎖保護起來，其他線程只能是在那裡等著，但是這個時候，線程的休眠喚醒，全部會消耗CPU資源，所以嘞，就會慢。

看到這個時候，我又發現了一個名詞：線程安全。這個名詞，也是那種特別熟悉，但就是無法清晰的說出它是啥的概念。查了資料，在這記一下：

線程安全就是多線程訪問時，採用了加鎖機制，當一個線程訪問該類的某個數據時，進行保護，其他線程不能進行訪問直到該線程讀取完，其他線程才可使用。不會出現數據不一致或者數據污染。 線程不安全就是不提供數據訪問保護，有可能出現多個線程先後更改數據造成所得到的數據是臟數據。

我自己想了一下，大約就是這樣，比如整個列表，倆個線程同時在列表中append操作，如果沒有鎖的保護，在機緣巧合之下，倆個線程同時先後申請了空間且沒來得及插入數據，然後這時列表中只會有一個空間，那麼在插入過程中只能有一個數據寫入，會造成不可知後果，有可能報錯終止，有可能有一個線程操作沒成功，那麼這個就是線程不安全了，大白話說，只要線程之間沒有共享資源，那麼就是線程安全的，有共享資源，為了保證線程安全，需要引進鎖的機制。

而後的文章中，有前輩做過實驗：

過程證明了因為GIL的存在，導致python在使用多線程的時候反而不如順序執行快。

此處我又溫習了一下python線程：

線程的順序執行還是多線程並發，取決於join函數的位置。join函數的作用是等待當前線程結束，所以每一個線程創建之後，調用start函數，這是在後面跟上該線程的join函數，那麼就是順序執行，如果多個線程先完成創建和start，最後加上join函數，那麼就變成了多線程並發。

這就是今天的學習內容，其實所有知識網上都能找到，更想分享的是一種學習的方法，一種本身很不推薦的學習方法，那就是類似於探索性測試的學習，啥不懂就去看啥，有些時候，我們學習東西確實不能非要究其內在，軟體行業的學習本身在非本行人事看來就特別神奇且枯燥，所以最初的學習，我們需要整個圖形界面，讓我們學到的東西有了成就感，如果上來先去研究機器碼，那麼沒幾個人願意學下去，但是不管怎樣，既然走上了軟體行業的道路，這種探索性，打破砂鍋問到底的學習，在我的感覺里應該是必經之路，也就是所謂的底層研究。以安卓開發舉例，如果做安卓開發的，雖然能寫出很漂亮的界面，解決所有的bug，如果不了解安卓系統linux層的知識，在我的眼裡，從未把這種研發看做大牛。當然我並不覺得不了解linux底層的安卓研發可以解決任何bug

當下的軟體行業進入了一個神奇的階段，我已經聽過無數遍的理論，培訓機構出來就能賺錢，大學讀著沒用，在這里不討論教育體制問題，從個人情感上，我覺得大學教育雖然沒有教給學生直接找工作的技能，但是給了所有學生一個能夠了解基礎知識的園地，換而言之，作為行業的一員，總應該有將行業發展起來的覺悟，行業內整體風氣，缺乏靜下心來的沉澱。在大談敏捷，行為驅動，機器學習的同時，自己需要靜下心來回頭看看，基礎已然不牢，再走下去是否有些危險。是不是學習軟體技術，就是為了獲取互聯網行業那虛高的工資，是否已經局限於第三方框架，一旦框架出現問題，只能打給客服而束手無策，是否有過沒有做任何嘗試就將bug歸咎於安卓系統，阿里中間件等等，是不是舊技術還沒用明白，為了新技術就可以不再去研究。

還是小菜鳥，在此大談行業發展難免有些放肆，如有不對的地方，還請各位前輩不吝指正

⑥ python gil對多進程有影響嗎

GIL對多進程完全沒有影響，只對多線程產生影響，在這里建議：計算密集型使用多進程，I/0密集型使用對線程

⑦ Python 的 GIL 是什麼鬼，多線程性能究竟如何

GIL是什麼

首先需要明確的一點是 GIL
並不是Python的特性，它是在實現Python解析器(CPython)時所引入的一個概念。就好比C++是一套語言（語法）標准，但是可以用不同的編譯器來編譯成可執行代碼。有名的編譯器例如GCC，INTEL
C++，Visual
C++等。Python也一樣，同樣一段代碼可以通過CPython，PyPy，Psyco等不同的Python執行環境來執行。像其中的JPython就沒有GIL。然而因為CPython是大部分環境下默認的Python執行環境。所以在很多人的概念里CPython就是Python，也就想當然的把
GIL 歸結為Python語言的缺陷。所以這里要先明確一點：GIL並不是Python的特性，Python完全可以不依賴於GIL

那麼CPython實現中的GIL又是什麼呢？GIL全稱 Global Interpreter Lock 為了避免誤導，我們還是來看一下官方給出的解釋：

In CPython, the global interpreter lock, or GIL, is a mutex that
prevents multiple native threads from executing Python bytecodes at
once. This lock is necessary mainly because CPython』s memory management
is not thread-safe. (However, since the GIL exists, other features have
grown to depend on the guarantees that it enforces.)

好吧，是不是看上去很糟糕？一個防止多線程並發執行機器碼的一個Mutex，乍一看就是個BUG般存在的全局鎖嘛！別急，我們下面慢慢的分析。

為什麼會有GIL

由於物理上得限制，各CPU廠商在核心頻率上的比賽已經被多核所取代。為了更有效的利用多核處理器的性能，就出現了多線程的編程方式，而隨之帶來的就是線程間數據一致性和狀態同步的困難。 即使在CPU內部的Cache也不例外 ，為了有效解決多份緩存之間的數據同步時各廠商花費了不少心思，也不可避免的帶來了一定的性能損失。

Python當然也逃不開，為了利用多核，Python開始支持多線程。 而解決多線程之間數據完整性和狀態同步的最簡單方法自然就是加鎖。 於是有了GIL這把超級大鎖，而當越來越多的代碼庫開發者接受了這種設定後，他們開始大量依賴這種特性（即默認python內部對象是thread-safe的，無需在實現時考慮額外的內存鎖和同步操作）。

慢慢的這種實現方式被發現是蛋疼且低效的。但當大家試圖去拆分和去除GIL的時候，發現大量庫代碼開發者已經重度依賴GIL而非常難以去除了。有多難？做個類比，像MySQL這樣的「小項目」為了把Buffer
Pool
Mutex這把大鎖拆分成各個小鎖也花了從5.5到5.6再到5.7多個大版為期近5年的時間，本且仍在繼續。MySQL這個背後有公司支持且有固定開發團隊的產品走的如此艱難，那又更何況Python這樣核心開發和代碼貢獻者高度社區化的團隊呢？

所以簡單的說GIL的存在更多的是歷史原因。如果推到重來，多線程的問題依然還是要面對，但是至少會比目前GIL這種方式會更優雅。

GIL的影響

從上文的介紹和官方的定義來看，GIL無疑就是一把全局排他鎖。毫無疑問全局鎖的存在會對多線程的效率有不小影響。甚至就幾乎等於Python是個單線程的程序。那麼讀者就會說了，全局鎖只要釋放的勤快效率也不會差啊。只要在進行耗時的IO操作的時候，能釋放GIL，這樣也還是可以提升運行效率的嘛。或者說再差也不會比單線程的效率差吧。理論上是這樣，而實際上呢？Python比你想的更糟。

下面我們就對比下Python在多線程和單線程下得效率對比。測試方法很簡單，一個循環1億次的計數器函數。一個通過單線程執行兩次，一個多線程執行。最後比較執行總時間。測試環境為雙核的Mac
pro。註：為了減少線程庫本身性能損耗對測試結果帶來的影響，這里單線程的代碼同樣使用了線程。只是順序的執行兩次，模擬單線程。

順序執行的單線程(single_thread.py)
#! /usr/bin/python
from threading import Thread
import time
def my_counter():
i = 0
for _ in range(100000000):
i = i + 1
return True
def main():
thread_array = {}
start_time = time.time()
for tid in range(2):
t = Thread(target=my_counter)
t.start()
thread_array[tid] = t
for i in range(2):
thread_array[i].join()
end_time = time.time()
print("Total time: {}".format(end_time - start_time))
if __name__ == '__main__':
main()

同時執行的兩個並發線程(multi_thread.py)
#! /usr/bin/python
from threading import Thread
import time
def my_counter():
i = 0
for _ in range(100000000):
i = i + 1
return True
def main():
thread_array = {}
start_time = time.time()
for tid in range(2):
t = Thread(target=my_counter)
t.start()
thread_array[tid] = t
for i in range(2):
thread_array[i].join()
end_time = time.time()
print("Total time: {}".format(end_time - start_time))
if __name__ == '__main__':
main()

⑧ python 什麼是全局解釋器鎖gil

什麼是Python全局解釋器鎖(GIL)?
每個CPU在同一時間只能執行一個線程，那麼其他的線程就必須等待該線程的全局解釋器，使用權消失後才能使用全局解釋器，即使多個線程直接不會相互影響在同一個進程下也只有一個線程使用CPU，這樣的機制稱為全局解釋器鎖(GIL)。GIL的設計簡化了CPython的實現，使得對象模型包括關鍵的內建類型，如：字典等，都是隱含的，可以並發訪問的，鎖住全局解釋器使得比較容易的實現對多線程的支持，但也損失了多處理器主機的並行計算能力。
Python全局解釋器鎖(GIL)是一種互斥鎖或鎖，僅允許一個線程持有Python解釋器的控制權。
全局解釋器鎖的好處
1、避免了大量的加鎖解鎖的好處;
2、使數據更加安全，解決多線程間的數據完整性和狀態同步。
全局解釋器鎖的劣勢
多核處理器退化成單核處理器，只能並發不能並行。
Python全局解釋器鎖(GIL)的作用
多線程情況下必須存在資源的競爭，GIL是為了保證在解釋器級別的線程唯一使用共享資源(cpu)。

⑨ python有了GIL，為什麼還有線程鎖

在python的原始解釋器CPython中存在著GIL（Global Interpreter Lock，全局解釋器鎖），因此在解釋執行python代碼時，會產生互斥鎖來限制線程對共享資源的訪問，直到解釋器遇到I/O操作或者操作次數達到一定數目時才會釋放GIL。

所以，雖然CPython的線程庫直接封裝了系統的原生線程，但CPython整體作為一個進程，同一時間只會有一個獲得GIL的線程在跑，其他線程則處於等待狀態。這就造成了即使在多核CPU中，多線程也只是做著分時切換而已。

不過muiltprocessing的出現，已經可以讓多進程的python代碼編寫簡化到了類似多線程的程度了。

⑩ Python的GIL是什麼，怎麼來的，對性能的影響

#!/usr/bin/python

fromthreadingimportThread
importtime

defmy_counter():
i=0
for_inrange(100000000):
i=i+1
returnTrue

defmain():
thread_array={}
start_time=time.time()
fortidinrange(2):
t=Thread(target=my_counter)
t.start()
t.join()
end_time=time.time()
print("Totaltime:{}".format(end_time-start_time))

if__name__=='__main__':
main()