同步的概念
同步就是協同步調，按預定的先后次序進行運行。如:你說完，我再說。
"同"字從字面上容易理解為一起動作
其實不是，"同"字應是指協同、協助、互相配合。
如進程、線程同步，可理解為進程或線程A和B一塊配合，A執行到一定程度時要依靠B的某個結果，于是停下來，示意B運行;B執行，再將結果給A;A再繼續操作。
解決線程同時修改全局變量的方式
對于上一小節提出的那個計算錯誤的問題，可以通過線程同步來進行解決
思路，如下:
系統調用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, 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=1909909 ---test2---g_num=2000000 2個線程對同一個全局變量操作之后的最終結果是:2000000
可以看到最后的結果，加入互斥鎖后，其結果與預期相符。
上鎖解鎖過程
當一個線程調用鎖的acquire()方法獲得鎖時，鎖就進入“locked”狀態。
每次只有一個線程可以獲得鎖。如果此時另一個線程試圖獲得這個鎖，該線程就會變為“blocked”狀態，稱為“阻塞”，直到擁有鎖的線程調用鎖的release()方法釋放鎖之后，鎖進入“unlocked”狀態。
線程調度程序從處于同步阻塞狀態的線程中選擇一個來獲得鎖，并使得該線程進入運行（running）狀態。
總結
鎖的好處：
確保了某段關鍵代碼只能由一個線程從頭到尾完整地執行
鎖的壞處：
阻止了多線程并發執行，包含鎖的某段代碼實際上只能以單線程模式執行，效率就大大地下降了
由于可以存在多個鎖，不同的線程持有不同的鎖，并試圖獲取對方持有的鎖時，可能會造成死鎖
死鎖
現實社會中，男女雙方都在等待對方先道歉
如果雙方都這樣固執的等待對方先開口，弄不好，就分搜了
1. 死鎖
在線程間共享多個資源的時候，如果兩個線程分別占有一部分資源并且同時等待對方的資源，就會造成死鎖。
盡管死鎖很少發生，但一旦發生就會造成應用的停止響應。下面看一個死鎖的例子
#coding=utf-8 import threading import time class MyThread1(threading.Thread): def run(self): # 對mutexA上鎖 mutexA.acquire() # mutexA上鎖后，延時1秒，等待另外那個線程 把mutexB上鎖 print(self.name+'----do1---up----') time.sleep(1) # 此時會堵塞，因為這個mutexB已經被另外的線程搶先上鎖了 mutexB.acquire() print(self.name+'----do1---down----') mutexB.release() # 對mutexA解鎖 mutexA.release() class MyThread2(threading.Thread): def run(self): # 對mutexB上鎖 mutexB.acquire() # mutexB上鎖后，延時1秒，等待另外那個線程 把mutexA上鎖 print(self.name+'----do2---up----') time.sleep(1) # 此時會堵塞，因為這個mutexA已經被另外的線程搶先上鎖了 mutexA.acquire() print(self.name+'----do2---down----') mutexA.release() # 對mutexB解鎖 mutexB.release() mutexA = threading.Lock() mutexB = threading.Lock() if __name__ == '__main__': t1 = MyThread1() t2 = MyThread2() t1.start() t2.start()
運行結果：
此時已經進入到了死鎖狀態，可以使用ctrl-c退出
2. 避免死鎖
程序設計時要盡量避免（銀行家算法）
添加超時時間等
附錄-銀行家算法
[背景知識]
一個銀行家如何將一定數目的資金安全地借給若干個客戶，使這些客戶既能借到錢完成要干的事，同時銀行家又能收回全部資金而不至于破產，這就是銀行家問題。這個問題同操作系統中資源分配問題十分相似：銀行家就像一個操作系統，客戶就像運行的進程，銀行家的資金就是系統的資源。
[問題的描述]
一個銀行家擁有一定數量的資金，有若干個客戶要貸款。每個客戶須在一開始就聲明他所需貸款的總額。若該客戶貸款總額不超過銀行家的資金總數，銀行家可以接收客戶的要求。客戶貸款是以每次一個資金單位（如1萬RMB等）的方式進行的，客戶在借滿所需的全部單位款額之前可能會等待，但銀行家須保證這種等待是有限的，可完成的。
例如：有三個客戶C1，C2，C3，向銀行家借款，該銀行家的資金總額為10個資金單位，其中C1客戶要借9各資金單位，C2客戶要借3個資金單位，C3客戶要借8個資金單位，總計20個資金單位。某一時刻的狀態如圖所示。
對于a圖的狀態，按照安全序列的要求，我們選的第一個客戶應滿足該客戶所需的貸款小于等于銀行家當前所剩余的錢款，可以看出只有C2客戶能被滿足：C2客戶需1個資金單位，小銀行家手中的2個資金單位，于是銀行家把1個資金單位借給C2客戶，使之完成工作并歸還所借的3個資金單位的錢，進入b圖。同理，銀行家把4個資金單位借給C3客戶，使其完成工作，在c圖中，只剩一個客戶C1，它需7個資金單位，這時銀行家有8個資金單位，所以C1也能順利借到錢并完成工作。最后（見圖d）銀行家收回全部10個資金單位，保證不賠本。那麼客戶序列{C1，C2，C3}就是個安全序列，按照這個序列貸款，銀行家才是安全的。否則的話，若在圖b狀態時，銀行家把手中的4個資金單位借給了C1，則出現不安全狀態：這時C1，C3均不能完成工作，而銀行家手中又沒有錢了，系統陷入僵持局面，銀行家也不能收回投資。
綜上所述，銀行家算法是從當前狀態出發，逐個按安全序列檢查各客戶誰能完成其工作，然后假定其完成工作且歸還全部貸款，再進而檢查下一個能完成工作的客戶，…。如果所有客戶都能完成工作，則找到一個安全序列，銀行家才是安全的。
