python線程lock

『壹』 python多個線程鎖可提高效率嗎

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

『貳』 深入解析Python中的線程同步方法

深入解析Python中的線程同步方法
同步訪問共享資源
在使用線程的時候，一個很重要的問題是要避免多個線程對同一變數或其它資源的訪問沖突。一旦你稍不留神，重疊訪問、在多個線程中修改（共享資源）等這些操作會導致各種各樣的問題；更嚴重的是，這些問題一般只會在比較極端（比如高並發、生產伺服器、甚至在性能更好的硬體設備上）的情況下才會出現。
比如有這樣一個情況：需要追蹤對一事件處理的次數
counter = 0

def process_item(item):
global counter
... do something with item ...
counter += 1
如果你在多個線程中同時調用這個函數，你會發現counter的值不是那麼准確。在大多數情況下它是對的，但有時它會比實際的少幾個。
出現這種情況的原因是，計數增加操作實際上分三步執行:
解釋器獲取counter的當前值計算新值將計算的新值回寫counter變數
考慮一下這種情況：在當前線程獲取到counter值後，另一個線程搶佔到了CPU，然後同樣也獲取到了counter值，並進一步將counter值重新計算並完成回寫；之後時間片重新輪到當前線程（這里僅作標識區分，並非實際當前），此時當前線程獲取到counter值還是原來的，完成後續兩步操作後counter的值實際只加上1。
另一種常見情況是訪問不完整或不一致狀態。這類情況主要發生在一個線程正在初始化或更新數據時，另一個進程卻嘗試讀取正在更改的數據。
原子操作
實現對共享變數或其它資源的同步訪問最簡單的方法是依靠解釋器的原子操作。原子操作是在一步完成執行的操作，在這一步中其它線程無法獲得該共享資源。
通常情況下，這種同步方法只對那些只由單個核心數據類型組成的共享資源有效，譬如，字元串變數、數字、列表或者字典等。下面是幾個線程安全的操作：
讀或者替換一個實例屬性讀或者替換一個全局變數從列表中獲取一項元素原位修改一個列表（例如：使用append增加一個列表項）從字典中獲取一項元素原位修改一個字典（例如：增加一個字典項、調用clear方法）
注意，上面提到過，對一個變數或者屬性進行讀操作，然後修改它，最終將其回寫不是線程安全的。因為另外一個線程會在這個線程讀完卻沒有修改或回寫完成之前更改這個共享變數/屬性。
鎖
鎖是Python的threading模塊提供的最基本的同步機制。在任一時刻，一個鎖對象可能被一個線程獲取，或者不被任何線程獲取。如果一個線程嘗試去獲取一個已經被另一個線程獲取到的鎖對象，那麼這個想要獲取鎖對象的線程只能暫時終止執行直到鎖對象被另一個線程釋放掉。
鎖通常被用來實現對共享資源的同步訪問。為每一個共享資源創建一個Lock對象，當你需要訪問該資源時，調用acquire方法來獲取鎖對象（如果其它線程已經獲得了該鎖，則當前線程需等待其被釋放），待資源訪問完後，再調用release方法釋放鎖：
lock = Lock()

lock.acquire() #: will block if lock is already held
... access shared resource
lock.release()

注意，即使在訪問共享資源的過程中出錯了也應該釋放鎖，可以用try-finally來達到這一目的：
lock.acquire()
try:
... access shared resource
finally:
lock.release() #: release lock, no matter what

在Python 2.5及以後的版本中，你可以使用with語句。在使用鎖的時候，with語句會在進入語句塊之前自動的獲取到該鎖對象，然後在語句塊執行完成後自動釋放掉鎖：
from __future__ import with_statement #: 2.5 only

with lock:
... access shared resource

acquire方法帶一個可選的等待標識，它可用於設定當有其它線程佔有鎖時是否阻塞。如果你將其值設為False，那麼acquire方法將不再阻塞，只是如果該鎖被佔有時它會返回False:
if not lock.acquire(False):
... 鎖資源失敗
else:
try:
... access shared resource
finally:
lock.release()

你可以使用locked方法來檢查一個鎖對象是否已被獲取，注意不能用該方法來判斷調用acquire方法時是否會阻塞，因為在locked方法調用完成到下一條語句（比如acquire）執行之間該鎖有可能被其它線程佔有。
if not lock.locked():
#: 其它線程可能在下一條語句執行之前佔有了該鎖
lock.acquire() #: 可能會阻塞

簡單鎖的缺點
標準的鎖對象並不關心當前是哪個線程佔有了該鎖；如果該鎖已經被佔有了，那麼任何其它嘗試獲取該鎖的線程都會被阻塞，即使是佔有鎖的這個線程。考慮一下下面這個例子：
lock = threading.Lock()

def get_first_part():
lock.acquire()
try:
... 從共享對象中獲取第一部分數據
finally:
lock.release()
return data

def get_second_part():
lock.acquire()
try:
... 從共享對象中獲取第二部分數據
finally:
lock.release()
return data

示例中，我們有一個共享資源，有兩個分別取這個共享資源第一部分和第二部分的函數。兩個訪問函數都使用了鎖來確保在獲取數據時沒有其它線程修改對應的共享數據。
現在，如果我們想添加第三個函數來獲取兩個部分的數據，我們將會陷入泥潭。一個簡單的方法是依次調用這兩個函數，然後返回結合的結果：

def get_both_parts():
first = get_first_part()
seconde = get_second_part()
return first, second

這里的問題是，如有某個線程在兩個函數調用之間修改了共享資源，那麼我們最終會得到不一致的數據。最明顯的解決方法是在這個函數中也使用lock:
def get_both_parts():
lock.acquire()
try:
first = get_first_part()
seconde = get_second_part()
finally:
lock.release()
return first, second

然而，這是不可行的。裡面的兩個訪問函數將會阻塞，因為外層語句已經佔有了該鎖。為了解決這個問題，你可以通過使用標記在訪問函數中讓外層語句釋放鎖，但這樣容易失去控制並導致出錯。幸運的是，threading模塊包含了一個更加實用的鎖實現：re-entrant鎖。
Re-Entrant Locks (RLock)

RLock類是簡單鎖的另一個版本，它的特點在於，同一個鎖對象只有在被其它的線程佔有時嘗試獲取才會發生阻塞；而簡單鎖在同一個線程中同時只能被佔有一次。如果當前線程已經佔有了某個RLock鎖對象，那麼當前線程仍能再次獲取到該RLock鎖對象。
lock = threading.Lock()
lock.acquire()
lock.acquire() #: 這里將會阻塞

lock = threading.RLock()
lock.acquire()
lock.acquire() #: 這里不會發生阻塞

RLock的主要作用是解決嵌套訪問共享資源的問題，就像前面描述的示例。要想解決前面示例中的問題，我們只需要將Lock換為RLock對象，這樣嵌套調用也會OK.
lock = threading.RLock()

def get_first_part():
... see above

def get_second_part():
... see above

def get_both_parts():
... see above

這樣既可以單獨訪問兩部分數據也可以一次訪問兩部分數據而不會被鎖阻塞或者獲得不一致的數據。
注意RLock會追蹤遞歸層級，因此記得在acquire後進行release操作。
Semaphores

信號量是一個更高級的鎖機制。信號量內部有一個計數器而不像鎖對象內部有鎖標識，而且只有當佔用信號量的線程數超過信號量時線程才阻塞。這允許了多個線程可以同時訪問相同的代碼區。
semaphore = threading.BoundedSemaphore()
semaphore.acquire() #: counter減小

... 訪問共享資源
semaphore.release() #: counter增大

當信號量被獲取的時候，計數器減小；當信號量被釋放的時候，計數器增大。當獲取信號量的時候，如果計數器值為0，則該進程將阻塞。當某一信號量被釋放，counter值增加為1時，被阻塞的線程（如果有的話）中會有一個得以繼續運行。
信號量通常被用來限制對容量有限的資源的訪問，比如一個網路連接或者資料庫伺服器。在這類場景中，只需要將計數器初始化為最大值，信號量的實現將為你完成剩下的事情。
max_connections = 10

semaphore = threading.BoundedSemaphore(max_connections)

如果你不傳任何初始化參數，計數器的值會被初始化為1.
Python的threading模塊提供了兩種信號量實現。Semaphore類提供了一個無限大小的信號量，你可以調用release任意次來增大計數器的值。為了避免錯誤出現，最好使用BoundedSemaphore類，這樣當你調用release的次數大於acquire次數時程序會出錯提醒。
線程同步

鎖可以用在線程間的同步上。threading模塊包含了一些用於線程間同步的類。
Events

一個事件是一個簡單的同步對象，事件表示為一個內部標識(internal flag)，線程等待這個標識被其它線程設定，或者自己設定、清除這個標識。
event = threading.Event()

#: 一個客戶端線程等待flag被設定
event.wait()

#: 服務端線程設置或者清除flag
event.set()
event.clear()

一旦標識被設定，wait方法就不做任何處理（不會阻塞），當標識被清除時，wait將被阻塞直至其被重新設定。任意數量的線程可能會等待同一個事件。
Conditions

條件是事件對象的高級版本。條件表現為程序中的某種狀態改變，線程可以等待給定條件或者條件發生的信號。
下面是一個簡單的生產者/消費者實例。首先你需要創建一個條件對象：

#: 表示一個資源的附屬項
condition = threading.Condition()
生產者線程在通知消費者線程有新生成資源之前需要獲得條件：
#: 生產者線程
... 生產資源項
condition.acquire()
... 將資源項添加到資源中
condition.notify() #: 發出有可用資源的信號
condition.release()
消費者必須獲取條件（以及相關聯的鎖），然後嘗試從資源中獲取資源項：
#: 消費者線程
condition.acquire()
while True:
...從資源中獲取資源項
if item:
break
condition.wait() #: 休眠，直至有新的資源
condition.release()
... 處理資源

wait方法釋放了鎖，然後將當前線程阻塞，直到有其它線程調用了同一條件對象的notify或者notifyAll方法，然後又重新拿到鎖。如果同時有多個線程在等待，那麼notify方法只會喚醒其中的一個線程，而notifyAll則會喚醒全部線程。
為了避免在wait方法處阻塞，你可以傳入一個超時參數，一個以秒為單位的浮點數。如果設置了超時參數，wait將會在指定時間返回，即使notify沒被調用。一旦使用了超時，你必須檢查資源來確定發生了什麼。
注意，條件對象關聯著一個鎖，你必須在訪問條件之前獲取這個鎖；同樣的，你必須在完成對條件的訪問時釋放這個鎖。在生產代碼中，你應該使用try-finally或者with.
可以通過將鎖對象作為條件構造函數的參數來讓條件關聯一個已經存在的鎖，這可以實現多個條件公用一個資源：
lock = threading.RLock()
condition_1 = threading.Condition(lock)
condition_2 = threading.Condition(lock)

互斥鎖同步
我們先來看一個例子：
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import time, threading

# 假定這是你的銀行存款:
balance = 0
muxlock = threading.Lock()

def change_it(n):
# 先存後取，結果應該為0:
global balance
balance = balance + n
balance = balance - n

def run_thread(n):
# 循環次數一旦多起來，最後的數字就變成非0
for i in range(100000):
change_it(n)

t1 = threading.Thread(target=run_thread, args=(5,))
t2 = threading.Thread(target=run_thread, args=(8,))
t3 = threading.Thread(target=run_thread, args=(9,))
t1.start()
t2.start()
t3.start()
t1.join()
t2.join()
t3.join()
print balance

結果 :

[/data/web/test_python]$ python multhread_threading.py
0
[/data/web/test_python]$ python multhread_threading.py
61
[/data/web/test_python]$ python multhread_threading.py
0
[/data/web/test_python]$ python multhread_threading.py
24

上面的例子引出了多線程編程的最常見問題：數據共享。當多個線程都修改某一個共享數據的時候，需要進行同步控制。
線程同步能夠保證多個線程安全訪問競爭資源，最簡單的同步機制是引入互斥鎖。互斥鎖為資源引入一個狀態：鎖定/非鎖定。某個線程要更改共享數據時，先將其鎖定，此時資源的狀態為「鎖定」，其他線程不能更改；直到該線程釋放資源，將資源的狀態變成「非鎖定」，其他的線程才能再次鎖定該資源。互斥鎖保證了每次只有一個線程進行寫入操作，從而保證了多線程情況下數據的正確性。

threading模塊中定義了Lock類，可以方便的處理鎖定：
#創建鎖mutex = threading.Lock()
#鎖定mutex.acquire([timeout])
#釋放mutex.release()

其中，鎖定方法acquire可以有一個超時時間的可選參數timeout。如果設定了timeout，則在超時後通過返回值可以判斷是否得到了鎖，從而可以進行一些其他的處理。
使用互斥鎖實現上面的例子的代碼如下：
balance = 0
muxlock = threading.Lock()

def change_it(n):
# 獲取鎖，確保只有一個線程操作這個數
muxlock.acquire()
global balance
balance = balance + n
balance = balance - n
# 釋放鎖，給其他被阻塞的線程繼續操作
muxlock.release()

def run_thread(n):
for i in range(10000):
change_it(n)

加鎖後的結果，就能確保數據正確：
[/data/web/test_python]$ python multhread_threading.py
0
[/data/web/test_python]$ python multhread_threading.py
0
[/data/web/test_python]$ python multhread_threading.py
0
[/data/web/test_python]$ python multhread_threading.py
0

『叄』 小白都看懂了，Python 中的線程和進程精講，建議收藏

目錄

眾所周知，CPU是計算機的核心，它承擔了所有的計算任務。而操作系統是計算機的管理者，是一個大管家，它負責任務的調度，資源的分配和管理，統領整個計算機硬體。應用程序是具有某種功能的程序，程序運行與操作系統之上

在很早的時候計算機並沒有線程這個概念，但是隨著時代的發展，只用進程來處理程序出現很多的不足。如當一個進程堵塞時，整個程序會停止在堵塞處，並且如果頻繁的切換進程，會浪費系統資源。所以線程出現了

線程是能擁有資源和獨立運行的最小單位，也是程序執行的最小單位。一個進程可以擁有多個線程，而且屬於同一個進程的多個線程間會共享該進行的資源

① 200 多本 Python 電子書（和經典的書籍）應該有

② Python標准庫資料（最全中文版）

③ 項目源碼（四五十個有趣且可靠的練手項目及源碼）

④ Python基礎入門、爬蟲、網路開發、大數據分析方面的視頻（適合小白學習）

⑤ Python學習路線圖（告別不入流的學習）
私信我01即可獲取大量Python學習資源

進程時一個具有一定功能的程序在一個數據集上的一次動態執行過程。進程由程序，數據集合和進程式控制制塊三部分組成。程序用於描述進程要完成的功能，是控制進程執行的指令集；數據集合是程序在執行時需要的數據和工作區；程序控制塊（PCB）包含程序的描述信息和控制信息，是進程存在的唯一標志

在Python中，通過兩個標准庫 thread 和 Threading 提供對線程的支持, threading 對 thread 進行了封裝。 threading 模塊中提供了 Thread , Lock , RLOCK , Condition 等組件

在Python中線程和進程的使用就是通過 Thread 這個類。這個類在我們的 thread 和 threading 模塊中。我們一般通過 threading 導入

默認情況下，只要在解釋器中，如果沒有報錯，則說明線程可用

守護模式：

現在我們程序代碼中，有多個線程， 並且在這個幾個線程中都會去 操作同一部分內容，那麼如何實現這些數據的共享呢？

這時，可以使用 threading庫裡面的鎖對象 Lock 去保護

Lock 對象的acquire方法 是申請鎖

每個線程在操作共享數據對象之前，都應該申請獲取操作權，也就是調用該共享數據對象對應的鎖對象的acquire方法，如果線程A 執行了 acquire() 方法，別的線程B 已經申請到了這個鎖， 並且還沒有釋放，那麼 線程A的代碼就在此處 等待 線程B 釋放鎖，不去執行後面的代碼。

直到線程B 執行了鎖的 release 方法釋放了這個鎖， 線程A 才可以獲取這個鎖，就可以執行下面的代碼了

如：

到在使用多線程時，如果數據出現和自己預期不符的問題，就可以考慮是否是共享的數據被調用覆蓋的問題

使用 threading 庫裡面的鎖對象 Lock 去保護

Python中的多進程是通過multiprocessing包來實現的，和多線程的threading.Thread差不多，它可以利用multiprocessing.Process對象來創建一個進程對象。這個進程對象的方法和線程對象的方法差不多也有start(), run(), join()等方法，其中有一個方法不同Thread線程對象中的守護線程方法是setDeamon，而Process進程對象的守護進程是通過設置daemon屬性來完成的

守護模式：

其使用方法和線程的那個 Lock 使用方法類似

Manager的作用是提供多進程共享的全局變數，Manager()方法會返回一個對象，該對象控制著一個服務進程，該進程中保存的對象運行其他進程使用代理進行操作

語法：

線程池的基類是 concurrent.futures 模塊中的 Executor ， Executor 提供了兩個子類，即 ThreadPoolExecutor 和 ProcessPoolExecutor ，其中 ThreadPoolExecutor 用於創建線程池，而 ProcessPoolExecutor 用於創建進程池

如果使用線程池/進程池來管理並發編程，那麼只要將相應的 task 函數提交給線程池/進程池，剩下的事情就由線程池/進程池來搞定

Exectuor 提供了如下常用方法：

程序將 task 函數提交（submit）給線程池後，submit 方法會返回一個 Future 對象，Future 類主要用於獲取線程任務函數的返回值。由於線程任務會在新線程中以非同步方式執行，因此，線程執行的函數相當於一個「將來完成」的任務，所以 Python 使用 Future 來代表

Future 提供了如下方法：

使用線程池來執行線程任務的步驟如下：

最佳線程數目 = （（線程等待時間+線程CPU時間）/線程CPU時間 ）* CPU數目

也可以低於 CPU 核心數

使用線程池來執行線程任務的步驟如下：

關於進程的開啟代碼一定要放在 if __name__ == '__main__': 代碼之下，不能放到函數中或其他地方

開啟進程的技巧

開啟進程的數量最好低於最大 CPU 核心數

『肆』 python線程怎麼銷毀

【Python】線程的創建、執行、互斥、同步、銷毀
還是《【Java】利用synchronized(this)完成線程的臨界區》（點擊打開鏈接）、《【Linux】線程互斥》（點擊打開鏈接）、《【C++】Windows線程的創建、執行、互斥、同步、銷毀》（點擊打開鏈接）中的設置多個線程對一個ticket進行自減操作，用來說明Python中多線程的運用，涉及的創建、執行、互斥、同步、銷毀問題。
運行結果如下，還是差不多，運行三次，每次的運行結果，每個線程最終的得票結果是不同的，但是4個線程最終「得票」的總和為 ticket 最初設置的值為100000，證明這4個線程成功實現了互斥。
雖然每次運行結果是不同，但是可以看得出每次運行結果大抵上是平均的。貌似Python對線程作系統資源的處理，比Java要好。
然而，Python總要實現多線程，代碼並不像想像中簡單，具體如下：
[python] view plain print?在CODE上查看代碼片派生到我的代碼片
# -*-coding:utf-8-*-
import threading;
mutex_lock = threading.RLock(); # 互斥鎖的聲明
ticket = 100000; # 總票數
# 用於統計各個線程的得票數
ticket_for_thread1 = 0;
ticket_for_thread2 = 0;
ticket_for_thread3 = 0;
ticket_for_thread4 = 0;
class myThread(threading.Thread): # 線程處理函數
def __init__(self, name):
threading.Thread.__init__(self); # 線程類必須的初始化
self.thread_name = name; # 將傳遞過來的name構造到類中的name
def run(self):
# 聲明在類中使用全局變數
global mutex_lock;
global ticket;
global ticket_for_thread1;
global ticket_for_thread2;
global ticket_for_thread3;
global ticket_for_thread4;
while 1:
mutex_lock.acquire(); # 臨界區開始，互斥的開始
# 僅能有一個線程↓↓↓↓↓↓↓↓↓↓↓↓
if ticket > 0:
ticket -= 1;
# 統計哪到線程拿到票
print "%s搶到了票！票還剩餘：%d。" % (self.thread_name, ticket);
if self.thread_name == "線程1":
ticket_for_thread1 += 1;
elif self.thread_name == "線程2":
ticket_for_thread2 += 1;
elif self.thread_name == "線程3":
ticket_for_thread3 += 1;
elif self.thread_name == "線程4":
ticket_for_thread4 += 1;
else:
break;
# 僅能有一個線程↑↑↑↑↑↑↑↑↑↑↑↑
mutex_lock.release(); # 臨界區結束，互斥的結束
mutex_lock.release(); # python在線程死亡的時候，不會清理已存在在線程函數的互斥鎖，必須程序猿自己主動清理
print "%s被銷毀了！" % (self.thread_name);
# 初始化線程
thread1 = myThread("線程1");
thread2 = myThread("線程2");
thread3 = myThread("線程3");
thread4 = myThread("線程4");
# 開啟線程
thread1.start();
thread2.start();
thread3.start();
thread4.start();
# 等到線程1、2、3、4結束才進行以下的代碼（同步）
thread1.join();
thread2.join();
thread3.join();
thread4.join();
print "票都搶光了，大家都散了吧！";
print "=========得票統計=========";
print "線程1：%d張" % (ticket_for_thread1);
print "線程2：%d張" % (ticket_for_thread2);
print "線程3：%d張" % (ticket_for_thread3);
print "線程4：%d張" % (ticket_for_thread4);
1、從上面的代碼可以看出，在Python2.7中要使用線程必須使用threading而不是古老的thread模塊。
如果你像網上部分遺留依舊的文章一樣，在Python2.7中使用thread來實現線程，至少在Eclipse的Pydev中會報錯：sys.excepthook is missing，lost sys.stderr如下圖所示：
所以必須使用現時Python建議使用的threading。
2、與其它編程語言類似，聲明一個互斥鎖，與一系列的得票數。之後，與Java同樣地，Python實現線程的函數，是要重寫一個類。而類中使用全局變數，則與同為腳本語言的php一樣《【php】global的使用與php的全局變數》（點擊打開鏈接），要用global才能使用這個全局變數，而不是C/C++可以直接使用。
3、需要注意的，Python需要在線程跑完class myThread(threading.Thread)這個類的def run(self)方法之前，必須自己手動清理互斥鎖，它不會像其它編程語言那樣，說線程跑完def run(self)方法，會自然而然地清理該線程被創建的互斥鎖。如果沒有最後一句手動清理互斥鎖，則會造成死鎖。
4、最後與其它編程語言一樣了，利用線程的join方法可以等待這個線程跑完def run(self)方法中的所有代碼，才執行之後的代碼，實現同步。否則主函數中的代碼，相當於與父線程。主函數開啟的線程，相當於其子線程，互不影響的。

『伍』 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常用的加鎖方式：互斥鎖、可重入鎖、迭代死鎖、互相調用死鎖、自旋鎖。

『陸』 Python多線程總結

在實際處理數據時，因系統內存有限，我們不可能一次把所有數據都導出進行操作，所以需要批量導出依次操作。為了加快運行，我們會採用多線程的方法進行數據處理， 以下為我總結的多線程批量處理數據的模板：

主要分為三大部分：

共分4部分對多線程的內容進行總結。

先為大家介紹線程的相關概念:

在飛車程序中，如果沒有多線程，我們就不能一邊聽歌一邊玩飛車，聽歌與玩 游戲 不能並行；在使用多線程後，我們就可以在玩 游戲 的同時聽背景音樂。在這個例子中啟動飛車程序就是一個進程，玩 游戲 和聽音樂是兩個線程。

Python 提供了 threading 模塊來實現多線程:

因為新建線程系統需要分配資源、終止線程系統需要回收資源，所以如果可以重用線程，則可以減去新建/終止的開銷以提升性能。同時，使用線程池的語法比自己新建線程執行線程更加簡潔。

Python 為我們提供了 ThreadPoolExecutor 來實現線程池，此線程池默認子線程守護。它的適應場景為突發性大量請求或需要大量線程完成任務，但實際任務處理時間較短。

其中 max_workers 為線程池中的線程個數，常用的遍歷方法有 map 和 submit+as_completed 。根據業務場景的不同，若我們需要輸出結果按遍歷順序返回，我們就用 map 方法，若想誰先完成就返回誰，我們就用 submit+as_complete 方法。

我們把一個時間段內只允許一個線程使用的資源稱為臨界資源，對臨界資源的訪問，必須互斥的進行。互斥，也稱間接制約關系。線程互斥指當一個線程訪問某臨界資源時，另一個想要訪問該臨界資源的線程必須等待。當前訪問臨界資源的線程訪問結束，釋放該資源之後，另一個線程才能去訪問臨界資源。鎖的功能就是實現線程互斥。

我把線程互斥比作廁所包間上大號的過程，因為包間里只有一個坑，所以只允許一個人進行大號。當第一個人要上廁所時，會將門上上鎖，這時如果第二個人也想大號，那就必須等第一個人上完，將鎖解開後才能進行，在這期間第二個人就只能在門外等著。這個過程與代碼中使用鎖的原理如出一轍，這里的坑就是臨界資源。 Python 的 threading 模塊引入了鎖。 threading 模塊提供了 Lock 類，它有如下方法加鎖和釋放鎖：

我們會發現這個程序只會列印「第一道鎖」，而且程序既沒有終止，也沒有繼續運行。這是因為 Lock 鎖在同一線程內第一次加鎖之後還沒有釋放時，就進行了第二次 acquire 請求，導致無法執行 release ，所以鎖永遠無法釋放，這就是死鎖。如果我們使用 RLock 就能正常運行，不會發生死鎖的狀態。

在主線程中定義 Lock 鎖，然後上鎖，再創建一個子 線程t 運行 main 函數釋放鎖，結果正常輸出，說明主線程上的鎖，可由子線程解鎖。

如果把上面的鎖改為 RLock 則報錯。在實際中設計程序時，我們會將每個功能分別封裝成一個函數，每個函數中都可能會有臨界區域，所以就需要用到 RLock 。

一句話總結就是 Lock 不能套娃， RLock 可以套娃； Lock 可以由其他線程中的鎖進行操作， RLock 只能由本線程進行操作。

『柒』 在Python中重新啟動一個線程問題，怎麼解決

給出一個簡單的線程互斥的例子，例子中同時啟動兩個線程，a線程獲取鎖，獲取後b線程處於等待狀態，只有a線程釋放鎖，才能進入b線程。代碼如下：

importthreading
importtime
defhello(name):
print(name+'started')
lock.acquire(True)
time.sleep(50)
print(name+'running')
lock.release()
print(name+'exit')
lock=threading.Lock()
a=threading.Thread(target=hello,args='a')
b=threading.Thread(target=hello,args='b')
a.start()
b.start()

『捌』 Python多線程之threading之Lock對象

要介紹Python的 threading 模塊中的 Lock 對象前, 首先應該了解以下兩個概念:

1.基本概念 : 指某個函數/函數庫在多線程環境中被調用時, 能夠正確地處理多個線程之間的 共享變數 , 使程序功能正常完成. 多個線程訪問同一個對象時, 如果不用考慮這些線程在運行時環境下的調度和交替執行, 也不需要進行額外的同步, 或者在調用方進行任何其他操作,調用這個對象的行為都可以獲得正確的結果, 那麼這個對象就是線程安全的. 或者說: 一個類或者程序所提供的介面對於線程來說是 原子操作 或者多個線程之間的切換不會導致該介面的執行結果存在二義性, 也就是說我們不用考慮同步的問題.

2.示例 : 比如有間銀行只有1000元, 而兩個人同時提領1000元時,就有可能拿到總計2000元的金額. 為了避免這個問題, 該間銀行提款時應該使用 互斥鎖 , 即意味著對同一個資源處理時, 前一個提領交易完成後才處理下一筆交易.

3.線程安全意義 :

4.是否線程安全 :

5.資源競爭 : 即多個線程對同一個資源的改寫時, 存在的一種競爭. 如果僅僅是讀操作, 則不存在資源競爭的情況.

1.基本概念 : 因為存在上述所說的 線程安全與資源競爭 的情況, 所以引入了 線程鎖 . 即通過鎖來進行資源請求的限制, 以保證同步執行,避免資源被污染或預期結果不符. 線程鎖存在兩種狀態: 鎖定(locked)和非鎖定(unlocked).

2.基本方法 :

3.使用示例 :

上述示例如果在不加鎖的情況下, 將會出現列印順序混亂的情況, 不過最終結果都是正確的, 因為即使線程交替執行, 但最終的結果都是一致.

『玖』 python多線程全局變數和鎖

1.python中數據類型，int,float,復數，字元，元組，做全局變數時需要在函數裡面用global申明變數，才能對變數進行操作。

而，對象，列表，詞典，不需要聲明，直接就是全局的。

2.線程鎖mutex=threading.Lock()

創建後就是全局的。線程調用函數可以直接在函數中使用。

mutex.acquire()開啟鎖

mutex=release()關閉鎖

要注意，死鎖的情況發生。

注意運行效率的變化:

正常1秒，完成56997921

加鎖之後，1秒只運行了531187，相差10倍多。

3.繼承.threading.Thread的類，無法調用__init__函數，無法在創建對象時初始化新建的屬性。

4.線程在cpu的執行，有隨機性

5. 新建線程時，需要傳參數時，args是一個元組，如果只有一個參數，一定後面要加一個,符號。不能只有一個參數否則線程會報創建參數錯誤。threading.Thread(target=fuc,args=(arg,))

『拾』 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):