一、同步概念

同步就是協同步調，按預定的先後次序進行執行。如:你說完，我再說。

"同"字從字面上容易理解為一起動作。

其實不是，在這裡，"同"字應是指協同、協助、互相配合。

執行緒同步，可理解為執行緒A和B一塊配合，A執行到一定程度時要依靠B的某個結果，於是停下來，示意B執行；B執行，再將結果給A；A再繼續操作。

之前我們遇到過，如果多個執行緒共同對某個資料修改，則可能出現不可預料的結果，為了保證資料的正確性，需要對多個執行緒進行同步。

解決執行緒同時修改全域性變數的方式

我們先把上次那個問題再看下。

import threading
import time

g_num = 0

def work1(num):
 global g_num
 for i in range(num):
  g_num += 1
 print("----in work1,g_num is %d---" % g_num)

def work2(num):
 global g_num
 for i in range(num):
  g_num += 1
 print("----in work2,g_num is %d---" % g_num)

print("---執行緒建立之前g_num is %d---" % g_num)

t1 = threading.Thread(target=work1,args=(1000000,))
t1.start()

t2 = threading.Thread(target=work2,))
t2.start()

# 確保子執行緒都執行結束
while len(threading.enumerate()) != 1:
 time.sleep(1)

print("2個執行緒對同一個全域性變數操作之後的最終結果是:%s" % g_num)

執行結果：

---執行緒建立之前g_num is 0---
----in work2,g_num is 1048576---
----in work1,g_num is 1155200---
2個執行緒對同一個全域性變數操作之後的最終結果是:1155200

對於這個計算錯誤的問題，可以通過執行緒同步來進行解決。

思路，如下:

系統呼叫 t1，然後獲取到 g_num 的值為0，此時上一把鎖，即不允許其他執行緒操作 g_num。

t1 對 g_num 的值進行+1。

t1 解鎖，此時 g_num 的值為1，其他的執行緒就可以使用 g_num 了，而且 g_num 的值不是0而是1。

同理其他執行緒在對 g_num 進行修改時，都要先上鎖，處理完後再解鎖，在上鎖的整個過程中不允許其他執行緒訪問，就保證了資料的正確性。

思路基本是這個樣子，那程式碼怎麼來實現呢？

二、互斥鎖解決資源競爭的問題

當多個執行緒幾乎同時修改某一個共享資料的時候，需要進行同步控制。

執行緒同步能夠保證多個執行緒安全訪問競爭資源，最簡單的同步機制就是引入互斥鎖。

互斥鎖為資源引入一個狀態：鎖定/非鎖定。

某個執行緒要更改共享資料時，先將其鎖定，此時資源的狀態為“鎖定”，其他執行緒不能更改；直到該執行緒釋放資源，將資源的狀態變成“非鎖定”，其他的執行緒才能再次鎖定該資源。

互斥鎖保證了每次只有一個執行緒進行寫入操作，從而保證了多執行緒情況下資料的正確性。

threading 模組中定義了 Lock 類，可以方便的處理鎖定：

# 建立鎖
mutex = threading.Lock()

# 鎖定
mutex.acquire()

# 釋放
mutex.release()

注意：

如果這個鎖之前是沒有上鎖的，那麼 acquire 不會堵塞。

如果在呼叫 acquire 對這個鎖上鎖之前，它已經被其他執行緒上了鎖，那麼此時 acquire 會堵塞，直到這個鎖被解鎖為止。

示例：

使用互斥鎖完成2個執行緒對同一個全域性變數各加100萬次的操作。

import threading
import time

g_num = 0

def test1(num):
 global g_num
 for i in range(num):
  mutex.acquire() # 上鎖
  g_num += 1
  mutex.release() # 解鎖

 print("---test1---g_num=%d" % g_num)

def test2(num):
 global g_num
 for i in range(num):
  mutex.acquire() # 上鎖
  g_num += 1
  mutex.release() # 解鎖

 print("---test2---g_num=%d" % g_num)

# 建立一個互斥鎖
# 預設是未上鎖的狀態
mutex = threading.Lock()

# 建立2個執行緒，讓他們各自對g_num加1000000次
p1 = threading.Thread(target=test1,))
p1.start()

p2 = threading.Thread(target=test2,))
p2.start()

# 等待計算完成
while len(threading.enumerate()) != 1:
 time.sleep(1)

print("2個執行緒對同一個全域性變數操作之後的最終結果是:%s" % g_num)

執行結果：

---test1---g_num=1989108
---test2---g_num=2000000
2個執行緒對同一個全域性變數操作之後的最終結果是:2000000

可以看到最後的結果，加入互斥鎖後，其結果與預期相符。

記住，上鎖的程式碼範圍要越小越好。在業務邏輯正確的前提下，能鎖一行程式碼，就不要鎖兩行。

上鎖解鎖過程

當一個執行緒呼叫鎖的 acquire() 方法獲得鎖時，鎖就進入“locked”狀態。

每次只有一個執行緒可以獲得鎖。

如果此時另一個執行緒試圖獲得這個鎖，該執行緒就會變為“blocked”狀態，稱為“阻塞”，直到擁有鎖的執行緒呼叫鎖的 release() 方法釋放鎖之後，鎖進入“unlocked”狀態。

執行緒排程程式從處於同步阻塞狀態的執行緒中選擇一個來獲得鎖，並使得該執行緒進入執行（running）狀態。

總結

鎖的好處：

確保了某段關鍵程式碼只能由一個執行緒從頭到尾完整地執行。

鎖的壞處：

阻止了多執行緒併發執行，包含鎖的某段程式碼實際上只能以單執行緒模式執行，效率就大大地下降了。

由於可以存在多個鎖，不同的執行緒持有不同的鎖，並試圖獲取對方持有的鎖時，可能會造成死鎖。

到此這篇關於互斥鎖解決 Python 中多執行緒共享全域性變數的問題的文章就介紹到這了,更多相關Python 多執行緒共享全域性變數內容請搜尋我們以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援我們！