多線程簡介

多線程：在一個進程內部，要同時干很多事情，就需要同時執行多個子任務，我們把進程內的這些子任務叫線程。
線程的內存空間是共享的，每個線程都共享同一個進程的資源
模塊：
1、_thread模塊 低級模塊（在python3里基本已棄用）
2、threading模塊 高級模塊 對_thread模塊進行了封裝

threading模塊使用

1.使用元組傳遞 threading.Thread(target=方法名，arg=(參數1，參數2...）)
2.用字典傳遞 threading.Thread(target=方法名，kwargs={“參數名”：參數1，“參數名”：參數2，....})
3.混合使用元組和字典 threading.Thread(target=方法名，args=(參數1，參數2，...)，kwargs={“參數名”：參數1，“參數名”：參數2，....})
4.查看線程數：
使用threading.enumerate()函數便可以看到當前線程的數量。
5.查看當前線程的名字：
使用threading.current_thread()可以看到當前線程的信息。
6.join([time]):等待至線程終止。這阻塞調用線程直至線程的join()方法被調用終止、正常退出或者拋出未處理的異常、或者是可選的超時發生。
7.isAlive（）：返回線程是否活動
8.getName(): 返回線程名
9.setNmae（）：設置線程名
10.後台線程（守護線程）
後台線程有一個特徵：如果所有的前台線程都死亡了，那麼後台線程也會自動死亡。
調用Thread對象的daemon屬性可將指定線程設置為後台線程。在下面程序可以看到程序里的線程被指定為後台線程，當所有前台程序都死亡了后，後台線程隨之死亡。當在整個虛擬機里只剩下後台線程時，程序就沒有繼續運行的必要了，所以程序也就退出了。

import threading
# 定義後台線程的線程執行體與普通線程沒有任何區別
def action(max):
    for i in range(max):
        print(threading.current_thread().name + "  " + str(i))
t = threading.Thread(target=action, args=(100,), name='後台線程')
# 將此線程設置成後台線程
# 也可在創建Thread對象時通過daemon參數將其設為後台線程
t.daemon = True
# 啟動後台線程
t.start()
for i in range(10):
    print(threading.current_thread().name + "  " + str(i))
# -----程序執行到此處，前台線程（主線程）結束------
# 後台線程也應該隨之結束

上面程序中的粗體字代碼先將t線程設置成後台線程,然後啟動該線程。本來該線程應該執行到i等於99時才會結束,但在運行程序時不難發現,該後台線程無法運行到99,因為當主線程也就是程序中唯一的前台線程運行結東后,程序會主動退出,所以後台線程也就被結東了。從上面的程序可以看出,主線程默認是前台線程,t線程默認也是前台線程。但並不是所有的線程默認都是前台線程,有些線程默認就是後台線程一一前台線程創建的子線程默認是前台線程，後台線程創建的子線程默認是後台線程
可見,創建後台線程有兩種方式。

1. 主動將線程的 daemon屬性設置為True
2. 後台線程啟動的線程默認是後台線程。

以下看一個簡單的多線程程序：

import threading
import time

def coding():
    for x in range(3):
        print('%s正在寫代碼' % x)
        time.sleep(1)

def drawing():
    for x in range(3):
        print('%s正在畫圖' % x)
        time.sleep(1)


def single_thread():
    coding()
    drawing()

def multi_thread():
    t1 = threading.Thread(target=coding)
    t2 = threading.Thread(target=drawing)

    t1.start()
    t2.start()

if __name__ == '__main__':
    multi_thread()

繼承自threading.Thread類：

為了讓線程代碼更好的封裝。可以使用threading模塊下的Thread類，繼承自這個類，然後實現run方法，線程就會自動運行run方法中的代碼。示例代碼如下：

import threading
import time

class CodingThread(threading.Thread):
    def run(self):
        for x in range(3):
            print('%s正在寫代碼' % threading.current_thread())
            time.sleep(1)

class DrawingThread(threading.Thread):
    def run(self):
        for x in range(3):
            print('%s正在畫圖' % threading.current_thread())
            time.sleep(1)

def multi_thread():
    t1 = CodingThread()
    t2 = DrawingThread()

    t1.start()
    t2.start()

if __name__ == '__main__':
    multi_thread()

start()和run()

start()
start（）方法來啟動線程，真正實現了多線程運行。這時無需等待run方法體代碼執行完畢，可以直接繼續執行下面的代碼；通過調用Thread類的start()方法來啟動一個線程， 這時此線程是處於就緒狀態， 並沒有運行。 然後通過此Thread類調用方法run()來完成其運行操作的， 這裏方法run()稱為線程體，它包含了要執行的這個線程的內容， Run方法運行結束， 此線程終止。然後CPU再調度其它線程。run()
run()
run（）方法當作普通方法的方式調用。程序還是要順序執行，要等待run方法體執行完畢后，才可繼續執行下面的代碼； 程序中只有主線程——這一個線程， 其程序執行路徑還是只有一條， 這樣就沒有達到寫線程的目的。
記住：多線程就是分時利用CPU，宏觀上讓所有線程一起執行 ，也叫併發。start() 和 run()的區別說明

start() : 它的作用是啟動一個新線程，新線程會執行相應的run()方法。start()不能被重複調用。
run() : run()就和普通的成員方法一樣，可以被重複調用。單獨調用run()的話，會在當前線程中執行run()，而並不會啟動新線程！

Lock版本生產者和消費者模型

生產者和消費者模式是多線程開發中經常見到的一種模式。生產者的線程專門用來生產一些數據，然後存放到一个中間的變量中。消費者再從這个中間的變量中取出數據進行消費。但是因為要使用中間變量，中間變量經常是一些全局變量，因此需要使用鎖來保證數據完整性。以下是使用threading.Lock鎖實現的“生產者與消費者模式”的一個例子：

import threading
import random
import time

gMoney = 1000
glo = threading.Lock()
gTotaltime = 10
gTime = 0
class Consumer(threading.Thread):
    def run(self):
        global gMoney
        global gTime
        while True:
            money = random.randint(100,1000)
            glo.acquire()
            if gMoney>= money:
                gMoney -= money
                print("{}消費了{}元，當前剩餘{}元".format(threading.current_thread(),money,gMoney))
            else:
                print("{}準備消費{}元，當前剩餘{}元，不足，不能消費".format(threading.current_thread(),money,gMoney))
            if gTime >= gTotaltime and money > gMoney:
                glo.release()
                break
            glo.release()
            time.sleep(0.7)

class Porducer(threading.Thread):
    def run(self):
        global gMoney
        global gTime
        while True:
            Money = random.randint(100,700)
            glo.acquire()
            if gTime == gTotaltime:
                glo.release()
                break
            gMoney += Money
            print("{}生產了{}元錢，剩餘{}元錢".format(threading.current_thread(),Money,gMoney))
            gTime += 1
            glo.release()
            time.sleep(0.5)

def main():
    for x in range(3):
       t1 = Porducer(name="生產者")
       t1.start()

    for i in range(5):
       t = Consumer(name="消費者")
       t.start()

if __name__ == '__main__':
    main()

queue線程安全隊列

在線程中，訪問一些全局變量，加鎖是一個經常的過程。如果你是想把一些數據存儲到某個隊列中，那麼Python內置了一個線程安全的模塊叫做queue模塊。Python中的queue模塊中提供了同步的、線程安全的隊列類，包括FIFO（先進先出）隊列Queue，LIFO（后入先出）隊列LifoQueue。這些隊列都實現了鎖原語（可以理解為原子操作，即要麼不做，要麼都做完），能夠在多線程中直接使用。可以使用隊列來實現線程間的同步。相關的函數如下：

1. 初始化Queue(maxsize)：創建一個先進先出的隊列。
2. qsize()：返回隊列的大小。
3. empty()：判斷隊列是否為空。
4. full()：判斷隊列是否滿了。
5. get()：從隊列中取最後一個數據。
6. put(item,block=Ture,timeout=None)：將一個數據放到隊列中。如果隊列已滿，且block參數為Ture（阻塞）,當前線程被阻塞，timeout指定阻塞時間，如果將timeout設置為None，則代表一直阻塞，直到有元素被放入隊列中：如果隊列已空，且block參數設置為False(不阻塞)，則直接引發queue.Empty異常。
   下面就可以用queue來進行線程通信

import queue
import time
import threading

def set_value(q):
    index = 0
    while True:
        q.put(index)
        index += 1
        time.sleep(3)

def get_value(q):
    index = 0
    while True:
        print(q.get())
        time.sleep(0.5)
def main():
    q = queue.Queue(4)
    t1 = threading.Thread(target=set_value,args=[q])
    t2 = threading.Thread(target=get_value,args=[q])
    t1.start()
    t2.start()


if __name__ == '__main__':
    main()

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※新北清潔公司,居家、辦公、裝潢細清專業服務

※別再煩惱如何寫文案,掌握八大原則!

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※超省錢租車方案

※教你寫出一流的銷售文案?