剛開始收到磁碟告警的時候，懷疑是日誌級別問題，業務日誌輸出過多導致磁碟打滿。但是查看我們自己的業務日誌文件目錄，每個日誌文件內容都不是很大。 ...
一、概述
在使用多線程的應用下，如何保證線程安全，以及線程之間的同步，或者訪問共用變數等問題是十分棘手的問題，也是使用多線程下麵臨的問題，如果處理不好，會帶來較嚴重的後果，使用python多線程中提供Lock 、Rlock 、Semaphore 、Event 、Condition 用來保證線程之間的同步，後者保證訪問共用變數的互斥問題。
- Lock & RLock：互斥鎖，用來保證多線程訪問共用變數的問題
- Semaphore對象：Lock互斥鎖的加強版，可以被多個線程同時擁有，而Lock只能被某一個線程同時擁有。
- Event對象：它是線程間通信的方式，相當於信號，一個線程可以給另外一個線程發送信號後讓其執行操作。
- Condition對象：其可以在某些事件觸發或者達到特定的條件後才處理數據
1、Lock(互斥鎖)
請求鎖定 — 進入鎖定池等待 — — 獲取鎖 — 已鎖定— — 釋放鎖
Lock（指令鎖）是可用的最低級的同步指令。Lock處於鎖定狀態時，不被特定的線程擁有。Lock包含兩種狀態——鎖定和非鎖定，以及兩個基本的方法。
可以認為Lock有一個鎖定池，當線程請求鎖定時，將線程至於池中，直到獲得鎖定後出池。池中的線程處於狀態圖中的同步阻塞狀態。
構造方法：mylock = Threading.Lock( )
實例方法：
- acquire([timeout]): 使線程進入同步阻塞狀態，嘗試獲得鎖定。
- release(): 釋放鎖。使用前線程必須已獲得鎖定，否則將拋出異常。
實例一（未使用鎖）：
import threading
import time
num = 0
def show(arg):
global num
time.sleep(1)
num +=1
print('bb :{}'.format(num))
for i in range(5):
t = threading.Thread(target=show, args=(i,)) # 註意傳入參數後一定要有【，】逗號
t.start()
print('main thread stop')
--------------------------------------------------------------------------
main thread stop
bb :1
bb :2
bb :3bb :4
bb :5
實例二（使用鎖）
import threading
import time
num = 0
lock = threading.RLock()
# 調用acquire([timeout])時，線程將一直阻塞，
# 直到獲得鎖定或者直到timeout秒後（timeout參數可選）。
# 返回是否獲得鎖。
def Func():
lock.acquire()
global num
num += 1
time.sleep(1)
print(num)
lock.release()
for i in range(10):
t = threading.Thread(target=Func)
t.start()
------------------------------------------------------------------
1
2
3
4
5
6
7
8
9
10
#可以看出，全局變數在在每次被調用時都要獲得鎖，才能操作，因此保證了共用數據的安全性
對於Lock對象而言，如果一個線程連續兩次release，使得線程死鎖。所以Lock不常用，一般採用Rlock進行線程鎖的設定。
import threading
import time
class MyThread(threading.Thread):
def run(self):
global num
time.sleep(1)
if lock.acquire(1):
num = num+1
msg = self.name+' set num to '+str(num)
print(msg)
lock.acquire()
lock.release()
lock.release()
num = 0
lock = threading.Lock()
def test():
for i in range(5):
t = MyThread()
t.start()
if __name__ == '__main__':
test()
------------------------------------------------------
Thread-12 set num to 1
2、RLock(可重入鎖)
RLock（可重入鎖）是一個可以被同一個線程請求多次的同步指令。RLock使用了“擁有的線程”和“遞歸等級”的概念，處於鎖定狀態時，RLock被某個線程擁有。擁有RLock的線程可以再次調用acquire()，釋放鎖時需要調用release()相同次數。可以認為RLock包含一個鎖定池和一個初始值為0的計數器，每次成功調用 acquire()/release()，計數器將+1/-1，為0時鎖處於未鎖定狀態。
-
構造方法：mylock = Threading.RLock()
-
實例方法：acquire([timeout])/release(): 跟Lock差不多。
實例解決死鎖，調用相同次數的acquire和release，保證成對出現
import threading
rLock = threading.RLock() #RLock對象
rLock.acquire()
rLock.acquire() #在同一線程內，程式不會堵塞。
rLock.release()
rLock.release()
print(rLock.acquire())
詳細實例：
import threading
mylock = threading.RLock()
num = 0
class WorkThread(threading.Thread):
def __init__(self, name):
threading.Thread.__init__(self)
self.t_name = name
def run(self):
global num
while True:
mylock.acquire()
print('\n%s locked, number: %d' % (self.t_name, num))
if num >= 2:
mylock.release()
print('\n%s released, number: %d' % (self.t_name, num))
break
num += 1
print('\n%s released, number: %d' % (self.t_name, num))
mylock.release()
def test(): #Python小白學習交流群：711312441
thread1 = WorkThread('A-Worker')
thread2 = WorkThread('B-Worker')
thread1.start()
thread2.start()
if __name__ == '__main__':
test()
--------------------------------------------------
A-Worker locked, number: 0
A-Worker released, number: 1
A-Worker locked, number: 1
A-Worker released, number: 2
A-Worker locked, number: 2
A-Worker released, number: 2
B-Worker locked, number: 2
B-Worker released, number: 2
