python線程鎖

A. python中的各種鎖

大致羅列一下：
一、全局解釋器鎖（GIL）
1、什麼是全局解釋器鎖
每個CPU在同一時間只能執行一個線程，那麼其他的線程就必須等待該線程的全局解釋器，使用權消失後才能使用全局解釋器，即使多個線程直接不會相互影響在同一個進程下也只有一個線程使用cpu，這樣的機制稱為全局解釋器鎖（GIL）。GIL的設計簡化了CPython的實現，使的對象模型包括關鍵的內建類型，如：字典等，都是隱含的，可以並發訪問的，鎖住全局解釋器使得比較容易的實現對多線程的支持，但也損失了多處理器主機的並行計算能力。
2、全局解釋器鎖的好處
1）、避免了大量的加鎖解鎖的好處
2）、使數據更加安全，解決多線程間的數據完整性和狀態同步
3、全局解釋器的缺點
多核處理器退化成單核處理器，只能並發不能並行。
4、GIL的作用：
多線程情況下必須存在資源的競爭，GIL是為了保證在解釋器級別的線程唯一使用共享資源（cpu）。
二、同步鎖
1、什麼是同步鎖？
同一時刻的一個進程下的一個線程只能使用一個cpu，要確保這個線程下的程序在一段時間內被cpu執，那麼就要用到同步鎖。
2、為什麼用同步鎖？
因為有可能當一個線程在使用cpu時，該線程下的程序可能會遇到io操作，那麼cpu就會切到別的線程上去，這樣就有可能會影響到該程序結果的完整性。
3、怎麼使用同步鎖？
只需要在對公共數據的操作前後加上上鎖和釋放鎖的操作即可。
4、同步鎖的所用：
為了保證解釋器級別下的自己編寫的程序唯一使用共享資源產生了同步鎖。
三、死鎖
1、什麼是死鎖？
指兩個或兩個以上的線程或進程在執行程序的過程中，因爭奪資源或者程序推進順序不當而相互等待的一個現象。
2、死鎖產生的必要條件？
互斥條件、請求和保持條件、不剝奪條件、環路等待條件
3、處理死鎖的基本方法？
預防死鎖、避免死鎖（銀行家演算法）、檢測死鎖（資源分配）、解除死鎖：剝奪資源、撤銷進程
四、遞歸鎖
在Python中為了支持同一個線程中多次請求同一資源，Python提供了可重入鎖。這個RLock內部維護著一個Lock和一個counter變數，counter記錄了acquire的次數，從而使得資源可以被多次require。直到一個線程所有的acquire都被release，其他的線程才能獲得資源。遞歸鎖分為可遞歸鎖與非遞歸鎖。
五、樂觀鎖
假設不會發生並發沖突，只在提交操作時檢查是否違反數據完整性。
六、悲觀鎖
假定會發生並發沖突，屏蔽一切可能違反數據完整性的操作。
python常用的加鎖方式：互斥鎖、可重入鎖、迭代死鎖、互相調用死鎖、自旋鎖。

B. python 多線程鎖應該加哪裡

匹配模式
re.I(re.IGNORECASE): 忽略大小寫（括弧內是完整寫法，下同）
M(MULTILINE): 多行模式，改變'^'和'$'的行為
S(DOTALL): 點任意匹配模式，改變'.'的行為！

C. python多個線程鎖可提高效率嗎

首先，Python的多線程本身就是效率極低的，因為有GIL（Global Interpreter Lock：全局解釋鎖）機制的限制，其作用簡單說就是：對於一個解釋器，只能有一個線程在執行bytecode。
所以如果為了追求傳統意義上多線程的效率，在Python界還是用多進程（multiprocessing)吧……
這里你用了多線程，且用了鎖來控制公共資源，首先鎖這個東西會導致死鎖，不加鎖反而沒有死鎖隱患，但會有同步問題。
另外，如果不同線程操作的是不同的文件，是不存在同步問題的，如果操作同一個文件，我建議採用Queue（隊列）來處理。
總的來說，用單線程就好了，因為Python多線程本身就沒什麼效率，而且單線程也不用考慮同步問題了。非要追求效率的話，就用多進程吧，同樣也要考慮進程鎖。

D. Python 進程，線程，協程，鎖機制，你知多少

1.線程和進程：
線程是屬於進程的，線程運行在進程空間內，同一進程所產生的線程共享同一內存空間，當進程退出時該進程所產生的線程都會被強制退出並清除。線程可與屬於同一進程的其它線程共享進程所擁有的全部資源，但是其本身基本上不擁有系統資源，只擁有一點在運行中必不可少的信息(如程序計數器、一組寄存器和棧)。

2.線程、進程與協程：
線程和進程的操作是由程序觸發系統介面，最後的執行者是系統；協程的操作則是程序員
協程存在的意義：對於多線程應用，CPU通過切片的方式來切換線程間的執行，線程切換時需要耗時（保持狀態，下次繼續）。協程，則只使用一個線程，在一個線程中規定某個代碼塊執行順序。
協程的適用場景： 當程序中存在大量不需要CPU的操作時（IO），適用於協程；

E. 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歸咎於安卓系統，阿里中間件等等，是不是舊技術還沒用明白，為了新技術就可以不再去研究。

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

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

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

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

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

G. python 多線程 改變變數需要加鎖么

python的鎖可以獨立提取出來

1
2
3
4
5
6
7
8

mutex = threading.Lock()
#鎖的使用
#創建鎖
mutex = threading.Lock()
#鎖定
mutex.acquire([timeout])
#釋放
mutex.release()

概念
好幾個人問我給資源加鎖是怎麼回事，其實並不是給資源加鎖, 而是用鎖去鎖定資源，你可以定義多個鎖, 像下面的代碼, 當你需要獨占某一資源時，任何一個鎖都可以鎖這個資源
就好比你用不同的鎖都可以把相同的一個門鎖住是一個道理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import threading
import time

counter = 0
counter_lock = threading.Lock() #只是定義一個鎖,並不是給資源加鎖,你可以定義多個鎖,像下兩行代碼,當你需要佔用這個資源時，任何一個鎖都可以鎖這個資源
counter_lock2 = threading.Lock()
counter_lock3 = threading.Lock()

#可以使用上邊三個鎖的任何一個來鎖定資源

class MyThread(threading.Thread):#使用類定義thread，繼承threading.Thread
def __init__(self,name):
threading.Thread.__init__(self)
self.name = "Thread-" + str(name)
def run(self): #run函數必須實現
global counter,counter_lock #多線程是共享資源的，使用全局變數
time.sleep(1);
if counter_lock.acquire(): #當需要獨佔counter資源時，必須先鎖定，這個鎖可以是任意的一個鎖，可以使用上邊定義的3個鎖中的任意一個
counter += 1
print "I am %s, set counter:%s" % (self.name,counter)
counter_lock.release() #使用完counter資源必須要將這個鎖打開，讓其他線程使用

if __name__ == "__main__":
for i in xrange(1,101):
my_thread = MyThread(i)
my_thread.start()

線程不安全:
最普通的一個多線程小例子。我一筆帶過地講一講，我創建了一個繼承Thread類的子類MyThread，作為我們的線程啟動類。按照規定，重寫Thread的run方法，我們的線程啟動起來後會自動調用該方法。於是我首先創建了10個線程，並將其加入列表中。再使用一個for循環，開啟每個線程。在使用一個for循環，調用join方法等待所有線程結束才退出主線程。
這段代碼看似簡單，但實際上隱藏著一個很大的問題，只是在這里沒有體現出來。你真的以為我創建了10個線程，並按順序調用了這10個線程，每個線程為n增加了1.實際上，有可能是A線程執行了n++，再C線程執行了n++，再B線程執行n++。
這里涉及到一個「鎖」的問題，如果有多個線程同時操作一個對象，如果沒有很好地保護該對象，會造成程序結果的不可預期（比如我們在每個線程的run方法中加入一個time.sleep(1)，並同時輸出線程名稱，則我們會發現，輸出會亂七八糟。因為可能我們的一個print語句只列印出一半的字元，這個線程就被暫停，執行另一個去了，所以我們看到的結果很亂），這種現象叫做「線程不安全」

線程鎖：
於是，Threading模塊為我們提供了一個類，Threading.Lock，鎖。我們創建一個該類對象，在線程函數執行前，「搶占」該鎖，執行完成後，「釋放」該鎖，則我們確保了每次只有一個線程佔有該鎖。這時候對一個公共的對象進行操作，則不會發生線程不安全的現象了。
於是，我們把代碼更改如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# coding : uft-8
__author__ = 'Phtih0n'
import threading, time
class MyThread(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
def run(self):
global n, lock
time.sleep(1)
if lock.acquire():
print n , self.name
n += 1
lock.release()
if "__main__" == __name__:
n = 1
ThreadList = []
lock = threading.Lock()
for i in range(1, 200):
t = MyThread()
ThreadList.append(t)
for t in ThreadList:
t.start()
for t in ThreadList:
t.join()

1
2
3
4
5
6
7
8
9
10
11

1 Thread-2
2 Thread-3
3 Thread-4
4 Thread-6
5 Thread-7
6 Thread-1
7 Thread-8
8 Thread-9
9 Thread-5

Process finished with exit code 0


我們看到，我們先建立了一個threading.Lock類對象lock,在run方法里，我們使用lock.acquire()獲得了這個鎖。此時，其他的線程就無法再獲得該鎖了，他們就會阻塞在「if lock.acquire()」這里，直到鎖被另一個線程釋放：lock.release()。
所以，if語句中的內容就是一塊完整的代碼，不會再存在執行了一半就暫停去執行別的線程的情況。所以最後結果是整齊的。
就如同在java中，我們使用synchronized關鍵字修飾一個方法，目的一樣，讓某段代碼被一個線程執行時，不會打斷跳到另一個線程中。
這是多線程佔用一個公共對象時候的情況。如果多個線程要調用多個現象，而A線程調用A鎖佔用了A對象，B線程調用了B鎖佔用了B對象,A線程不能調用B對象，B線程不能調用A對象，於是一直等待。這就造成了線程「死鎖」。
Threading模塊中，也有一個類，RLock，稱之為可重入鎖。該鎖對象內部維護著一個Lock和一個counter對象。counter對象記錄了acquire的次數，使得資源可以被多次require。最後，當所有RLock被release後，其他線程才能獲取資源。在同一個線程中，RLock.acquire可以被多次調用，利用該特性，可以解決部分死鎖問題。

H. skynet 為什麼不用python 線程鎖

物信息、統計、網頁製作、計算等多個領域都體現出了強大的功能。python和其他腳本語言如java、R、Perl 一樣，都可以直接在命令行里運行腳本程序。工具/原料
python；CMD命令行；windows操作系統
方法/步驟
1、首先下載安裝python，建議安裝2.7版本以上，3.0版本以下，由於3.0版本以上不向下兼容，體驗較差。

2、打開文本編輯器，推薦editplus，notepad等，將文件保存成 .py格式，editplus和notepad支持識別python語法。
腳本第一行一定要寫上 #!usr/bin/python
表示該腳本文件是可執行python腳本
如果python目錄不在usr/bin目錄下，則替換成當前python執行程序的目錄。
3、編寫完腳本之後注意調試、可以直接用editplus調試。調試方法可自行網路。腳本寫完之後，打開CMD命令行，前提是python 已經被加入到環境變數中，如果沒有加入到環境變數，請網路

4、在CMD命令行中，輸入 「python」 + 「空格」，即 」python 「；將已經寫好的腳本文件拖拽到當前游標位置，然後敲回車運行即可。

I. python線程有幾種鎖

普通的一個多線程小例子。我一筆帶過地講一講，我創建了一個繼承Thread類的子類MyThread，作為我們的線程啟動類。按照規定，重寫Thread的run方法，我們的線程啟動起來後會自動調用該方法。於是我首先創建了10個線程，並將其加入列表中。
再使用一個for循環，開啟每個線程。在使用一個for循環，調用join方法等待所有線程結束才退出主線程。