python的thread模塊是比較底層的模塊，python的threading模塊是對thread做了一些包裝的，可以更加方便的被使用

查看線程數(shù)量

#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āng)前運(yùn)行的線程數(shù)為：%d'%length)
        if length<=1:
            break

        sleep(0.5)

結(jié)果

---開始---:Thu Dec 27 11:22:19 2018
正在唱歌...0
正在跳舞...0
當(dāng)前運(yùn)行的線程數(shù)為：3
當(dāng)前運(yùn)行的線程數(shù)為：3
正在唱歌...1
正在跳舞...1
當(dāng)前運(yùn)行的線程數(shù)為：3
當(dāng)前運(yùn)行的線程數(shù)為：3
正在唱歌...2
正在跳舞...2
當(dāng)前運(yùn)行的線程數(shù)為：3
當(dāng)前運(yùn)行的線程數(shù)為：3
當(dāng)前運(yùn)行的線程數(shù)為：1

當(dāng)調(diào)用Thread的時候不會創(chuàng)建線程只是創(chuàng)建了一個對象，只有在調(diào)用start的時候才會創(chuàng)建
通過使用threading模塊能完成多任務(wù)的程序開發(fā)，為了讓每個線程的封裝性更完美，所以使用threading模塊時，往往會定義一個新的子類class，只要繼承threading.Thread就可以了，然后重寫run方法，這里調(diào)用start其實就是調(diào)用了Thread的run方法。

• python的threading.Thread類有一個run方法，用于定義線程的功能函數(shù)，可以在自己的線程類中覆蓋該方法。而創(chuàng)建自己的線程實例后，通過Thread類的start方法，可以啟動該線程，交給python虛擬機(jī)進(jìn)行調(diào)度，當(dāng)該線程獲得執(zhí)行的機(jī)會時，就會調(diào)用run方法執(zhí)行線程。

#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()

執(zhí)行結(jié)果：

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

從代碼和執(zhí)行結(jié)果我們可以看出，多線程程序的執(zhí)行順序是不確定的。當(dāng)執(zhí)行到sleep語句時，線程將被阻塞（Blocked），到sleep結(jié)束后，線程進(jìn)入就緒（Runnable）狀態(tài)，等待調(diào)度。而線程調(diào)度將自行選擇一個線程執(zhí)行。上面的代碼中只能保證每個線程都運(yùn)行完整個run函數(shù)，但是線程的啟動順序、run函數(shù)中每次循環(huán)的執(zhí)行順序都不能確定。

總結(jié)
1、每個線程默認(rèn)有一個名字，盡管上面的例子中沒有指定線程對象的name，但是python會自動為線程指定一個名字。
2、當(dāng)線程的run()方法結(jié)束時該線程完成。
3、無法控制線程調(diào)度程序，但可以通過別的方式來影響線程調(diào)度的方式

互斥鎖

當(dāng)多個線程幾乎同時修改某一個共享數(shù)據(jù)的時候，需要進(jìn)行同步控制。線程同步能夠保證多個線程安全訪問競爭資源，最簡單的同步機(jī)制是引入互斥鎖。互斥鎖為資源引入一個狀態(tài)：鎖定/非鎖定

某個線程要更改共享數(shù)據(jù)時，先將其鎖定，此時資源的狀態(tài)為“鎖定”，其他線程不能更改；直到該線程釋放資源，將資源的狀態(tài)變成“非鎖定”，其他的線程才能再次鎖定該資源。互斥鎖保證了每次只有一個線程進(jìn)行寫入操作，從而保證了多線程情況下數(shù)據(jù)的正確性。

threading模塊中定義了Lock類，可以方便的處理鎖定：

# 創(chuàng)建鎖
mutex = threading.Lock()

# 鎖定
mutex.acquire()

# 釋放
mutex.release()

注意：
如果這個鎖之前是沒有上鎖的，那么acquire不會堵塞
如果在調(diào)用acquire對這個鎖上鎖之前 它已經(jīng)被 其他線程上了鎖，那么此時acquire會堵塞，直到這個鎖被解鎖為止

import threading
import time

g_num = 0

def test1(num):
    global g_num
    for i in range(num):
        #如果之前沒被上鎖，那么上鎖成功
        #如果之前已經(jīng)被上鎖了，那么會堵塞在這里，直到這個鎖被解開
        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)

# 創(chuàng)建一個互斥鎖
# 默認(rèn)是未上鎖的狀態(tài)
mutex = threading.Lock()

# 創(chuàng)建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個線程對同一個全局變量操作之后的最終結(jié)果是:%s" % g_num)

運(yùn)行結(jié)果

---test1---g_num=1000000

---test2---g_num=2000000

2個線程對同一個全局變量操作之后的最終結(jié)果是:2000000

第一個線程上鎖直到執(zhí)行完之后才到第二個線程繼續(xù)執(zhí)行。 上鎖的位置不同，產(chǎn)生的效果也會不同，如果將子線程對數(shù)據(jù)操作的代碼進(jìn)行上鎖，則兩個線程將交叉對數(shù)據(jù)進(jìn)行操作，修改示例如下

  for i in range(num):
        mutex.acquire()  # 上鎖
        g_num += 1
        mutex.release()  # 解鎖

運(yùn)行結(jié)果：

---test2---g_num=1768428
---test1---g_num=2000000
2個線程對同一個全局變量操作之后的最終結(jié)果是:2000000

上鎖解鎖過程
當(dāng)一個線程調(diào)用鎖的acquire()方法獲得鎖時，鎖就進(jìn)入“l(fā)ocked”狀態(tài)。
每次只有一個線程可以獲得鎖。如果此時另一個線程試圖獲得這個鎖，該線程就會變?yōu)椤癰locked”狀態(tài)，稱為“阻塞”，直到擁有鎖的線程調(diào)用鎖的release()方法釋放鎖之后，鎖進(jìn)入“unlocked”狀態(tài)。
線程調(diào)度程序從處于同步阻塞狀態(tài)的線程中選擇一個來獲得鎖，并使得該線程進(jìn)入運(yùn)行（running）狀態(tài)。

總結(jié)
鎖的好處：

• 確保了某段關(guān)鍵代碼只能由一個線程從頭到尾完整地執(zhí)行

鎖的壞處：

• 阻止了多線程并發(fā)執(zhí)行，包含鎖的某段代碼實際上只能以單線程模式執(zhí)行，效率就大大地下降了
• 由于可以存在多個鎖，不同的線程持有不同的鎖，并試圖獲取對方持有的鎖時，可能會造成死鎖