一、同步概念

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

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

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

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

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

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

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

importthreadingimporttimeg_num =0defwork1(num):globalg_numforiinrange(num):? ? ? ? g_num +=1print("----in work1, g_num is %d---"% g_num)defwork2(num):globalg_numforiinrange(num):? ? ? ? g_num +=1print("----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()# 確保子線程都運行結束whilelen(threading.enumerate()) !=1:? ? time.sleep(1)print("2個線程對同一個全局變量操作之后的最終結果是:%s"% g_num)

運行結果：

---線程創建之前g_numis0-------inwork2,g_numis1048576-------inwork1,g_numis1155200---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萬次的操作。

importthreadingimporttimeg_num =0deftest1(num):globalg_numforiinrange(num):? ? ? ? mutex.acquire()# 上鎖g_num +=1mutex.release()# 解鎖print("---test1---g_num=%d"% g_num)deftest2(num):globalg_numforiinrange(num):? ? ? ? mutex.acquire()# 上鎖g_num +=1mutex.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()# 等待計算完成whilelen(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系統學習教程， 想要這些資料的可以關注私信小編“01”即可（免費分享哦）希望能對你有所幫助。