一、同步概念

同步就是協(xié)同步調(diào)，按預(yù)定的先后次序進(jìn)行運(yùn)行。如:你說完，我再說。

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

其實(shí)不是，在這里，"同"字應(yīng)是指協(xié)同、協(xié)助、互相配合。

線程同步，可理解為線程A和B一塊配合，A執(zhí)行到一定程度時要依靠B的某個結(jié)果，于是停下來，示意B運(yùn)行；B執(zhí)行，再將結(jié)果給A；A再繼續(xù)操作。

之前我們遇到過，如果多個線程共同對某個數(shù)據(jù)修改，則可能出現(xiàn)不可預(yù)料的結(jié)果，為了保證數(shù)據(jù)的正確性，需要對多個線程進(jìn)行同步。

解決線程同時修改全局變量的方式

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

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("---線程創(chuàng)建之前g_num is %d---" % g_num)

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

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

# 確保子線程都運(yùn)行結(jié)束
while len(threading.enumerate()) != 1:
 time.sleep(1)

print("2個線程對同一個全局變量操作之后的最終結(jié)果是:%s" % g_num)

運(yùn)行結(jié)果：

---線程創(chuàng)建之前g_num is 0---
----in work2, g_num is 1048576---
----in work1, g_num is 1155200---
2個線程對同一個全局變量操作之后的最終結(jié)果是:1155200

對于這個計算錯誤的問題，可以通過線程同步來進(jìn)行解決。

思路，如下:

系統(tǒng)調(diào)用 t1，然后獲取到 g_num 的值為0，此時上一把鎖，即不允許其他線程操作 g_num。

t1 對 g_num 的值進(jìn)行+1。

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

同理其他線程在對 g_num 進(jìn)行修改時，都要先上鎖，處理完后再解鎖，在上鎖的整個過程中不允許其他線程訪問，就保證了數(shù)據(jù)的正確性。

思路基本是這個樣子，那代碼怎么來實(shí)現(xiàn)呢？

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

當(dāng)多個線程幾乎同時修改某一個共享數(shù)據(jù)的時候，需要進(jìn)行同步控制。

線程同步能夠保證多個線程安全訪問競爭資源，最簡單的同步機(jī)制就是引入互斥鎖。

互斥鎖為資源引入一個狀態(tài)：鎖定/非鎖定。

某個線程要更改共享數(shù)據(jù)時，先將其鎖定，此時資源的狀態(tài)為“鎖定”，其他線程不能更改；直到該線程釋放資源，將資源的狀態(tài)變成“非鎖定”，其他的線程才能再次鎖定該資源。

互斥鎖保證了每次只有一個線程進(jìn)行寫入操作，從而保證了多線程情況下數(shù)據(jù)的正確性。

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

# 創(chuàng)建鎖
mutex = threading.Lock()

# 鎖定
mutex.acquire()

# 釋放
mutex.release()

注意：

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

如果在調(diào)用 acquire 對這個鎖上鎖之前，它已經(jīng)被其他線程上了鎖，那么此時 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)

# 創(chuàng)建一個互斥鎖
# 默認(rèn)是未上鎖的狀態(tài)
mutex = threading.Lock()

# 創(chuàng)建2個線程，讓他們各自對g_num加1000000次
p1 = threading.Thread(target=test1, args=(1000000,))
p1.start()

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

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

print("2個線程對同一個全局變量操作之后的最終結(jié)果是:%s" % g_num)

運(yùn)行結(jié)果：

---test1---g_num=1989108
---test2---g_num=2000000
2個線程對同一個全局變量操作之后的最終結(jié)果是:2000000

可以看到最后的結(jié)果，加入互斥鎖后，其結(jié)果與預(yù)期相符。

記住，上鎖的代碼范圍要越小越好。在業(yè)務(wù)邏輯正確的前提下，能鎖一行代碼，就不要鎖兩行。

上鎖解鎖過程

當(dāng)一個線程調(diào)用鎖的 acquire() 方法獲得鎖時，鎖就進(jìn)入“l(fā)ocked”狀態(tài)。

每次只有一個線程可以獲得鎖。

如果此時另一個線程試圖獲得這個鎖，該線程就會變?yōu)椤癰locked”狀態(tài)，稱為“阻塞”，直到擁有鎖的線程調(diào)用鎖的 release() 方法釋放鎖之后，鎖進(jìn)入“unlocked”狀態(tài)。

線程調(diào)度程序從處于同步阻塞狀態(tài)的線程中選擇一個來獲得鎖，并使得該線程進(jìn)入運(yùn)行（running）狀態(tài)。

總結(jié)

鎖的好處：

確保了某段關(guān)鍵代碼只能由一個線程從頭到尾完整地執(zhí)行。

鎖的壞處：

阻止了多線程并發(fā)執(zhí)行，包含鎖的某段代碼實(shí)際上只能以單線程模式執(zhí)行，效率就大大地下降了。

由于可以存在多個鎖，不同的線程持有不同的鎖，并試圖獲取對方持有的鎖時，可能會造成死鎖。

到此這篇關(guān)于互斥鎖解決 Python 中多線程共享全局變量的問題的文章就介紹到這了,更多相關(guān)Python 多線程共享全局變量內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！