python的thread模塊是比較底層的模塊，python的threading模塊是對thread做了一些包裝的，可以更加方便的被使用
查看線程數量
#coding=utf-8
import threading
from time import sleep,ctime
def sing():
for i in range(3):
print("正在唱歌...%d"%i)
sleep(1)
def dance():
for i in range(3):
print("正在跳舞...%d"%i)
sleep(1)
if __name__ == '__main__':
print('---開始---:%s'%ctime())
t1 = threading.Thread(target=sing)
t2 = threading.Thread(target=dance)
t1.start()
t2.start()
while True:
length = len(threading.enumerate())
print('當前運行的線程數爲：%d'%length)
if length<=1:
break
sleep(0.5)
結果
---開始---:Thu Dec 27 11:22:19 2018
正在唱歌...0
正在跳舞...0
當前運行的線程數爲：3
當前運行的線程數爲：3
正在唱歌...1
正在跳舞...1
當前運行的線程數爲：3
當前運行的線程數爲：3
正在唱歌...2
正在跳舞...2
當前運行的線程數爲：3
當前運行的線程數爲：3
當前運行的線程數爲：1
當調用Thread的時候不會創建線程只是創建了一個對象，只有在調用start的時候纔會創建
通過使用threading模塊能完成多任務的程序開發，爲了讓每個線程的封裝性更完美，所以使用threading模塊時，往往會定義一個新的子類class，只要繼承threading.Thread就可以了，然後重寫run方法，這裏調用start其實就是調用了Thread的run方法。
- python的threading.Thread類有一個run方法，用於定義線程的功能函數，可以在自己的線程類中覆蓋該方法。而創建自己的線程實例後，通過Thread類的start方法，可以啓動該線程，交給python虛擬機進行調度，當該線程獲得執行的機會時，就會調用run方法執行線程。
#coding=utf-8
import threading
import time
class MyThread(threading.Thread):
def run(self):
for i in range(3):
time.sleep(1)
msg = "I'm "+self.name+' @ '+str(i)
print(msg)
def test():
for i in range(5):
t = MyThread()
t.start()
if __name__ == '__main__':
test()
執行結果：
I'm Thread-1 @ 0
I'm Thread-3 @ 0
I'm Thread-2 @ 0
I'm Thread-4 @ 0
I'm Thread-5 @ 0
I'm Thread-1 @ 1
I'm Thread-3 @ 1
I'm Thread-2 @ 1
I'm Thread-4 @ 1
I'm Thread-5 @ 1
I'm Thread-1 @ 2
I'm Thread-2 @ 2
I'm Thread-3 @ 2
I'm Thread-4 @ 2
I'm Thread-5 @ 2
從代碼和執行結果我們可以看出，多線程程序的執行順序是不確定的。當執行到sleep語句時，線程將被阻塞（Blocked），到sleep結束後，線程進入就緒（Runnable）狀態，等待調度。而線程調度將自行選擇一個線程執行。上面的代碼中只能保證每個線程都運行完整個run函數，但是線程的啓動順序、run函數中每次循環的執行順序都不能確定。
總結
1、每個線程默認有一個名字，儘管上面的例子中沒有指定線程對象的name，但是python會自動爲線程指定一個名字。
2、當線程的run()方法結束時該線程完成。
3、無法控制線程調度程序，但可以通過別的方式來影響線程調度的方式
互斥鎖
當多個線程幾乎同時修改某一個共享數據的時候，需要進行同步控制。線程同步能夠保證多個線程安全訪問競爭資源，最簡單的同步機制是引入互斥鎖。互斥鎖爲資源引入一個狀態：鎖定/非鎖定
某個線程要更改共享數據時，先將其鎖定，此時資源的狀態爲“鎖定”，其他線程不能更改；直到該線程釋放資源，將資源的狀態變成“非鎖定”，其他的線程才能再次鎖定該資源。互斥鎖保證了每次只有一個線程進行寫入操作，從而保證了多線程情況下數據的正確性。
threading模塊中定義了Lock類，可以方便的處理鎖定：
# 創建鎖
mutex = threading.Lock()
# 鎖定
mutex.acquire()
# 釋放
mutex.release()
注意：
如果這個鎖之前是沒有上鎖的，那麼acquire不會堵塞
如果在調用acquire對這個鎖上鎖之前 它已經被 其他線程上了鎖，那麼此時acquire會堵塞，直到這個鎖被解鎖爲止
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=1000000
---test2---g_num=2000000
2個線程對同一個全局變量操作之後的最終結果是:2000000
第一個線程上鎖直到執行完之後纔到第二個線程繼續執行。 上鎖的位置不同，產生的效果也會不同，如果將子線程對數據操作的代碼進行上鎖，則兩個線程將交叉對數據進行操作，修改示例如下
for i in range(num):
mutex.acquire() # 上鎖
g_num += 1
mutex.release() # 解鎖
運行結果：
---test2---g_num=1768428
---test1---g_num=2000000
2個線程對同一個全局變量操作之後的最終結果是:2000000
上鎖解鎖過程
當一個線程調用鎖的acquire()方法獲得鎖時，鎖就進入“locked”狀態。
每次只有一個線程可以獲得鎖。如果此時另一個線程試圖獲得這個鎖，該線程就會變爲“blocked”狀態，稱爲“阻塞”，直到擁有鎖的線程調用鎖的release()方法釋放鎖之後，鎖進入“unlocked”狀態。
線程調度程序從處於同步阻塞狀態的線程中選擇一個來獲得鎖，並使得該線程進入運行（running）狀態。
總結
鎖的好處：
- 確保了某段關鍵代碼只能由一個線程從頭到尾完整地執行
鎖的壞處：
- 阻止了多線程併發執行，包含鎖的某段代碼實際上只能以單線程模式執行，效率就大大地下降了
- 由於可以存在多個鎖，不同的線程持有不同的鎖，並試圖獲取對方持有的鎖時，可能會造成死鎖