python多線程鎖
Python編程面試題目一：python下多線程的限制以及多進程中傳遞參數的方式，以及區別
(1)python下多線程的限制以及多進程中傳遞參數的方式
python多線程有個全局解釋器鎖(global interpreter lock)，這個鎖的意思是任一時間只能有一個線程使用解釋器，跟單cpu跑多個程序一個意思，大家都是輪著用的，這叫“並發”，不是“並行”。
多進程間共享數據，可以使用 multiprocessing.Value 和 multiprocessing.Array
(2)python多線程與多進程的區別
在UNIX平台上，當某個進程終結之後，該進程需要被其父進程調用wait，否則進程成為僵屍進程(Zombie)。所以，有必要對每個Process對象調用join()方法 (實際上等同於wait)。對於多線程來說，由於只有一個進程，所以不存在此必要性。
多進程應該避免共享資源。在多線程中，我們可以比較容易地共享資源，比如使用全局變數或者傳遞參數。在多進程情況下，由於每個進程有自己獨立的內存空間，以上方法並不合適。此時我們可以通過共享內存和Manager的方法來共享資源。但這樣做提高了程序的復雜度，並因為同步的需要而降低了程序的效率。
Python編程面試題目二：lambada函數
lambda 函數是一個可以接收任意多個參數(包括可選參數)並且返回單個表達式值的函數。 lambda 函數不能包含命令，它們所包含的表達式不能超過一個。不要試圖向lambda 函數中塞入太多的東西;如果你需要更復雜的東西，應該定義一個普通函數，然後想讓它多長就多長。
更多關於Python編程的技巧，干貨，資訊等內容，小編會持續更新。
2. Python多線程問題，怎麼解決
在python里線程出問題，可能會導致主進程崩潰。 雖然python里的線程是操作系統的真實線程。
那麼怎麼解決呢？通過我們用進程方式。子進程崩潰後，會完全的釋放所有的內存和錯誤狀態。所以進程更安全。 另外通過進程，python可以很好的繞過GIL，這個全局鎖問題。
但是進程也是有局限的。不要建立超過CPU總核數的進程，否則效率也不高。
簡單的總結一下。
當我們想實現多任務處理時，首先要想到使用multiprocessing， 但是如果覺著進程太笨重，那麼就要考慮使用線程。 如果多任務處理中需要處理的太多了，可以考慮多進程，每個進程再採用多線程。如果還處理不要，就要使用輪詢模式，比如使用poll event, twisted等方式。如果是GUI方式，則要通過事件機制，或者是消息機制處理，GUI使用單線程。
所以在python里線程不要盲目用， 也不要濫用。 但是線程不安全是事實。如果僅僅是做幾個後台任務，則可以考慮使用守護線程做。如果需要做一些危險操作，可能會崩潰的，就用子進程去做。 如果需要高度穩定性，同時並發數又不高的服務。則強烈建議用多進程的multiprocessing模塊實現。
在linux或者是unix里，進程的使用代價沒有windows高。還是可以接受的。
3. 為什麼有人說 Python 的多線程是雞肋
因為 Python 中臭名昭著的 GIL。
那麼 GIL 是什麼？為什麼會有 GIL？多線程真的是雞肋嗎？ GIL 可以去掉嗎？帶著這些問題，我們一起往下看，同時需要你有一點點耐心。
多線程是不是雞肋，我們先做個實驗，實驗非常簡單，就是將數字 「1億」 遞減，減到 0 程序就終止，這個任務如果我們使用單線程來執行，完成時間會是多少？使用多線程又會是多少？show me the code
那麼把 GIL 去掉可行嗎？
還真有人這么干多，但是結果令人失望，在1999年Greg Stein 和Mark Hammond 兩位哥們就創建了一個去掉 GIL 的 Python 分支，在所有可變數據結構上把 GIL 替換為更為細粒度的鎖。然而，做過了基準測試之後，去掉GIL的 Python 在單線程條件下執行效率將近慢了2倍。
Python之父表示：基於以上的考慮，去掉GIL沒有太大的價值而不必花太多精力。
4. python多線程的幾種方法
Python進階(二十六)-多線程實現同步的四種方式
臨界資源即那些一次只能被一個線程訪問的資源，典型例子就是列印機，它一次只能被一個程序用來執行列印功能，因為不能多個線程同時操作，而訪問這部分資源的代碼通常稱之為臨界區。
鎖機制
threading的Lock類，用該類的acquire函數進行加鎖，用realease函數進行解鎖
import threadingimport timeclass Num:
def __init__(self):
self.num = 0
self.lock = threading.Lock() def add(self):
self.lock.acquire()#加鎖，鎖住相應的資源
self.num += 1
num = self.num
self.lock.release()#解鎖，離開該資源
return num
n = Num()class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item def run(self):
time.sleep(2)
value = n.add()#將num加1，並輸出原來的數據和+1之後的數據
print(self.item,value)for item in range(5):
t = jdThread(item)
t.start()
t.join()#使線程一個一個執行
當一個線程調用鎖的acquire()方法獲得鎖時，鎖就進入「locked」狀態。每次只有一個線程可以獲得鎖。如果此時另一個線程試圖獲得這個鎖，該線程就會變為「blocked」狀態，稱為「同步阻塞」（參見多線程的基本概念）。
直到擁有鎖的線程調用鎖的release()方法釋放鎖之後，鎖進入「unlocked」狀態。線程調度程序從處於同步阻塞狀態的線程中選擇一個來獲得鎖，並使得該線程進入運行（running）狀態。
信號量
信號量也提供acquire方法和release方法，每當調用acquire方法的時候，如果內部計數器大於0，則將其減1，如果內部計數器等於0，則會阻塞該線程，知道有線程調用了release方法將內部計數器更新到大於1位置。
import threadingimport timeclass Num:
def __init__(self):
self.num = 0
self.sem = threading.Semaphore(value = 3) #允許最多三個線程同時訪問資源
def add(self):
self.sem.acquire()#內部計數器減1
self.num += 1
num = self.num
self.sem.release()#內部計數器加1
return num
n = Num()class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item def run(self):
time.sleep(2)
value = n.add()
print(self.item,value)for item in range(100):
5. python 怎麼實現多線程的
線程也就是輕量級的進程，多線程允許一次執行多個線程，Python是多線程語言，它有一個多線程包，GIL也就是全局解釋器鎖，以確保一次執行單個線程，一個線程保存GIL並在將其傳遞給下一個線程之前執行一些操作，也就產生了並行執行的錯覺。
6. python 多進程和多線程配合
由於python的多線程中存在PIL鎖，因此python的多線程不能利用多核，那麼，由於現在的計算機是多核的，就不能充分利用計算機的多核資源。但是python中的多進程是可以跑在不同的cpu上的。因此，嘗試了多進程+多線程的方式，來做一個任務。比如：從中科大的鏡像源中下載多個rpm包。
#!/usr/bin/pythonimport reimport commandsimport timeimport multiprocessingimport threadingdef download_image(url):
print '*****the %s rpm begin to download *******' % url
commands.getoutput('wget %s' % url)def get_rpm_url_list(url):
commands.getoutput('wget %s' % url)
rpm_info_str = open('index.html').read()
regu_mate = '(?<=<a href=")(.*?)(?=">)'
rpm_list = re.findall(regu_mate, rpm_info_str)
rpm_url_list = [url + rpm_name for rpm_name in rpm_list] print 'the count of rpm list is: ', len(rpm_url_list) return rpm_url_
def multi_thread(rpm_url_list):
threads = [] # url = 'https://mirrors.ustc.e.cn/centos/7/os/x86_64/Packages/'
# rpm_url_list = get_rpm_url_list(url)
for index in range(len(rpm_url_list)): print 'rpm_url is:', rpm_url_list[index]
one_thread = threading.Thread(target=download_image, args=(rpm_url_list[index],))
threads.append(one_thread)
thread_num = 5 # set threading pool, you have put 4 threads in it
while 1:
count = min(thread_num, len(threads)) print '**********count*********', count ###25,25,...6707%25
res = [] for index in range(count):
x = threads.pop()
res.append(x) for thread_index in res:
thread_index.start() for j in res:
j.join() if not threads:
def multi_process(rpm_url_list):
# process num at the same time is 4
process = []
rpm_url_group_0 = []
rpm_url_group_1 = []
rpm_url_group_2 = []
rpm_url_group_3 = [] for index in range(len(rpm_url_list)): if index % 4 == 0:
rpm_url_group_0.append(rpm_url_list[index]) elif index % 4 == 1:
rpm_url_group_1.append(rpm_url_list[index]) elif index % 4 == 2:
rpm_url_group_2.append(rpm_url_list[index]) elif index % 4 == 3:
rpm_url_group_3.append(rpm_url_list[index])
rpm_url_groups = [rpm_url_group_0, rpm_url_group_1, rpm_url_group_2, rpm_url_group_3] for each_rpm_group in rpm_url_groups:
each_process = multiprocessing.Process(target = multi_thread, args = (each_rpm_group,))
process.append(each_process) for one_process in process:
one_process.start() for one_process in process:
one_process.join()# for each_url in rpm_url_list:# print '*****the %s rpm begin to download *******' %each_url## commands.getoutput('wget %s' %each_url)
def main():
url = 'https://mirrors.ustc.e.cn/centos/7/os/x86_64/Packages/'
url_paas = 'http://mirrors.ustc.e.cn/centos/7.3.1611/paas/x86_64/openshift-origin/'
url_paas2 ='http://mirrors.ustc.e.cn/fedora/development/26/Server/x86_64/os/Packages/u/'
start_time = time.time()
rpm_list = get_rpm_url_list(url_paas) print multi_process(rpm_list) # print multi_thread(rpm_list)
#print multi_process()
# print multi_thread(rpm_list)
# for index in range(len(rpm_list)):
# print 'rpm_url is:', rpm_list[index]
end_time = time.time() print 'the download time is:', end_time - start_timeprint main()123456789101112131415161718
代碼的功能主要是這樣的：
main（）方法中調用get_rpm_url_list（base_url）方法，獲取要下載的每個rpm包的具體的url地址。其中base_url即中科大基礎的鏡像源的地址，比如：http://mirrors.ustc.e.cn/centos/7.3.1611/paas/x86_64/openshift-origin/，這個地址下有幾十個rpm包，get_rpm_url_list方法將每個rpm包的url地址拼出來並返回。
multi_process（rpm_url_list）啟動多進程方法，在該方法中，會調用多線程方法。該方法啟動4個多進程，將上面方法得到的rpm包的url地址進行分組，分成4組，然後每一個組中的rpm包再最後由不同的線程去執行。從而達到了多進程+多線程的配合使用。
代碼還有需要改進的地方，比如多進程啟動的進程個數和rpm包的url地址分組是硬編碼，這個還需要改進，畢竟，不同的機器，適合同時啟動的進程個數是不同的。
7. 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可以被多次調用，利用該特性，可以解決部分死鎖問題。
8. python有了GIL，為什麼還有線程鎖
在python的原始解釋器CPython中存在著GIL（Global Interpreter Lock，全局解釋器鎖），因此在解釋執行python代碼時，會產生互斥鎖來限制線程對共享資源的訪問，直到解釋器遇到I/O操作或者操作次數達到一定數目時才會釋放GIL。
所以，雖然CPython的線程庫直接封裝了系統的原生線程，但CPython整體作為一個進程，同一時間只會有一個獲得GIL的線程在跑，其他線程則處於等待狀態。這就造成了即使在多核CPU中，多線程也只是做著分時切換而已。
不過muiltprocessing的出現，已經可以讓多進程的python代碼編寫簡化到了類似多線程的程度了。