一、同步概念

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

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

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

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

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

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

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

import threadingimport timeg_num = 0def 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, args=(1000000,))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 threadingimport timeg_num = 0def 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, args=(1000000,))p1.start()p2 = threading.Thread(target=test2, args=(1000000,))p2.start()# 等待計算完成while len(threading.enumerate()) != 1: time.sleep(1)print('2個線程對同一個全局變量操作之后的最終結果是:%s' % g_num)

運行結果：

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

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

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

上鎖解鎖過程

當一個線程調用鎖的 acquire() 方法獲得鎖時，鎖就進入“locked”狀態。

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

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

線程調度程序從處于同步阻塞狀態的線程中選擇一個來獲得鎖，并使得該線程進入運行（running）狀態。

總結

鎖的好處：

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

鎖的壞處：

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

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

到此這篇關于互斥鎖解決 Python 中多線程共享全局變量的問題的文章就介紹到這了,更多相關Python 多線程共享全局變量內容請搜索好吧啦網以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持好吧啦網！