python 線程并發(fā)
在本章中，我們將學習如何在python中實現線程。
用于線程實現的python模塊
python線程有時被稱為輕量級進程，因為線程占用的內存比進程少得多。線程允許一次執(zhí)行多個任務。在python中，我們有以下兩個在程序中實現線程的模塊
<_thread>模塊模塊
這兩個模塊之間的主要區(qū)別在于 模塊將線程視為一個函數，而 模塊將每個線程視為一個對象，并以面向對象的方式實現它。此外， < _thread>模塊在低級線程中是有效的，并且具有比< threading>模塊更少的功能。
<_thread>模塊
在早期版本的python中，我們使用了 模塊，但很長一段時間它被認為是“已棄用”。鼓勵用戶改為使用 模塊。因此，在python 3中，模塊thread不再可用。它已被重命名為 <_thread>，以便在python3中向后兼容。
要在 <_thread>模塊的幫助下生成新線程，我們需要調用它的 start_new_thread方法。借助以下語法可以理解此方法的工作原理
_thread.start_new_thread ( function, args[, kwargs] )
在這里
- args 是一個參數元組
- kwargs 是關鍵字參數的可選字典
如果我們想在不傳遞參數的情況下調用函數，那么我們需要在 args中 使用一個空元組 參數 。
此方法調用立即返回，子線程啟動，并使用傳遞的args列表（如果有）調用函數。線程在函數返回時終止。
例
以下是使用 <_thread>模塊生成新線程的示例。我們在這里使用start_new_thread（）方法。
import _thread
import time
def print_time( threadname, delay):
count = 0
while count < 5:
time.sleep(delay)
count += 1
print ("%s: %s" % ( threadname, time.ctime(time.time()) ))
try:
_thread.start_new_thread( print_time, ("thread-1", 2, ) )
_thread.start_new_thread( print_time, ("thread-2", 4, ) )
except:
print ("error: unable to start thread")
while 1:
pass 輸出
以下輸出將幫助我們在 <_thread>模塊的幫助下理解新線程的生成。
thread-1: mon apr 23 10:03:33 2018 thread-2: mon apr 23 10:03:35 2018 thread-1: mon apr 23 10:03:35 2018 thread-1: mon apr 23 10:03:37 2018 thread-2: mon apr 23 10:03:39 2018 thread-1: mon apr 23 10:03:39 2018 thread-1: mon apr 23 10:03:41 2018 thread-2: mon apr 23 10:03:43 2018 thread-2: mon apr 23 10:03:47 2018 thread-2: mon apr 23 10:03:51 2018
所述 模塊實現在面向對象的方式并設為每個線程作為對象。因此，它為線程提供了比<_thread>模塊更強大，更高級的支持。該模塊包含在python2.4中。
所述 模塊包括的所有方法 <_thread>模塊，但它提供了額外的方法為好。其他方法如下 -
threading.activecount（）- 此方法返回活動的線程對象的數量threading.currentthread（）- 此方法返回調用者線程控件中的線程對象數。threading.enumerate（）- 此方法返回當前活動的所有線程對象的列表。
為了實現線程， 模塊有 thread 類，它提供以下方法
* run（） \- run（）方法是線程的入口點。
* start（） \- start（）方法通過調用run方法啟動一個線程。
* join（[time]） \- join（）等待線程終止。
* isalive（） \- isalive（）方法檢查線程是否仍在執(zhí)行。
* getname（） \- getname（）方法返回線程的名稱。
* setname（） \- setname（）方法設置線程的名稱。
如何使用
在本節(jié)中，我們將學習如何使用 模塊創(chuàng)建線程。按照以下步驟使用模塊創(chuàng)建新線程
- 第1步 - 在這一步中，我們需要定義
thread類的新子類。 - 第2步 - 然后，為了添加其他參數，我們需要覆蓋
__init __（self [，args]）方法。 - 第3步 - 在這一步中，我們需要覆蓋
run（self [，args]）方法來實現線程在啟動時應該做的事情。
現在，在創(chuàng)建新的 thread 子類之后，我們可以創(chuàng)建它的一個實例，然后通過調用 start（） 啟動一個新線程， start（） 又調用 run（） 方法。
例
考慮此示例以了解如何使用 模塊生成新線程。
import threading
import time
exitflag = 0
class mythread (threading.thread):
def __init__(self, threadid, name, counter):
threading.thread.__init__(self)
self.threadid = threadid
self.name = name
self.counter = counter
def run(self):
print ("starting " + self.name)
print_time(self.name, self.counter, 5)
print ("exiting " + self.name)
def print_time(threadname, delay, counter):
while counter:
if exitflag:
threadname.exit()
time.sleep(delay)
print ("%s: %s" % (threadname, time.ctime(time.time())))
counter -= 1
thread1 = mythread(1, "thread-1", 1)
thread2 = mythread(2, "thread-2", 2)
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print ("exiting main thread")
starting thread-1
starting thread-2 輸出
現在，考慮以下輸出
thread-1: mon apr 23 10:52:09 2018 thread-1: mon apr 23 10:52:10 2018 thread-2: mon apr 23 10:52:10 2018 thread-1: mon apr 23 10:52:11 2018 thread-1: mon apr 23 10:52:12 2018 thread-2: mon apr 23 10:52:12 2018 thread-1: mon apr 23 10:52:13 2018 exiting thread-1 thread-2: mon apr 23 10:52:14 2018 thread-2: mon apr 23 10:52:16 2018 thread-2: mon apr 23 10:52:18 2018 exiting thread-2 exiting main thread
各種線程狀態(tài)的python程序
有五種線程狀態(tài) - 新的，可運行的，運行的，等待的和死的。在這五個中，我們主要關注三個州 跑步，等待和死亡。線程將其資源置于運行狀態(tài)，等待處于等待狀態(tài)的資源; 資源的最終版本，如果執(zhí)行和獲取處于死亡狀態(tài)。
以下python程序在start（），sleep（）和join（）方法的幫助下將分別顯示線程如何進入running，waiting和dead狀態(tài)。
步驟1 - 導入必要的模塊， 和
import threading import time
第2步 - 定義一個函數，在創(chuàng)建線程時將調用該函數。
def thread_states():
print("thread entered in running state") 第3步 - 我們使用time模塊的sleep（）方法讓我們的線程等待2秒鐘。
time.sleep(2)
第4步 - 現在，我們創(chuàng)建一個名為t1的線程，它接受上面定義的函數的參數。
t1 = threading.thread(target=thread_states)
第5步 - 現在，在start（）函數的幫助下，我們可以啟動我們的線程。 它將生成消息，該消息由我們在定義函數時設置。
t1.start() thread entered in running state
第6步 - 現在，最后我們可以在完成執(zhí)行后使用join（）方法終止該線程。
t1.join()
在python中啟動一個線程
在python中，我們可以通過不同的方式啟動一個新線程，但其中最簡單的一個是將它定義為單個函數。定義函數后，我們可以將其作為新的 threading.thread 對象的目標傳遞。執(zhí)行以下python代碼以了解該函數的工作原理
import threading
import time
import random
def thread_execution(i):
print("execution of thread {} started\n".format(i))
sleeptime = random.randint(1,4)
time.sleep(sleeptime)
print("execution of thread {} finished".format(i))
for i in range(4):
thread = threading.thread(target=thread_execution, args=(i,))
thread.start()
print("active threads:" , threading.enumerate()) 輸出
execution of thread 0 started
active threads:
[<_mainthread(mainthread, started 6040)>,
,
]
execution of thread 1 started
active threads:
[<_mainthread(mainthread, started 6040)>,
,
,
]
execution of thread 2 started
active threads:
[<_mainthread(mainthread, started 6040)>,
,
,
,
]
execution of thread 3 started
active threads:
[<_mainthread(mainthread, started 6040)>,
,
,
,
,
]
execution of thread 0 finished
execution of thread 1 finished
execution of thread 2 finished
execution of thread 3 finished
python中的守護程序線程
在python中實現守護程序線程之前，我們需要了解守護程序線程及其用法。在計算方面，守護進程是一個后臺進程，它處理各種服務的請求，例如數據發(fā)送，文件傳輸等。如果不再需要它，它將處于休眠狀態(tài)。同樣的任務也可以在非守護程序線程的幫助下完成。但是，在這種情況下，主線程必須手動跟蹤非守護程序線程。另一方面，如果我們使用守護程序線程，那么主線程可以完全忘記這一點，它將在主線程退出時被終止。關于守護程序線程的另一個重要觀點是，我們可以選擇僅將它們用于非必要任務，如果它們沒有完成或在它們之間被殺死則不會影響我們。以下是python中守護程序線程的實現
import threading
import time
def nondaemonthread():
print("starting my thread")
time.sleep(8)
print("ending my thread")
def daemonthread():
while true:
print("hello")
time.sleep(2)
if __name__ == '__main__':
nondaemonthread = threading.thread(target = nondaemonthread)
daemonthread = threading.thread(target = daemonthread)
daemonthread.setdaemon(true)
daemonthread.start()
nondaemonthread.start() 在上面的代碼中，有兩個函數，即 nondaemonthread（） 和 daemonthread（） 。第一個函數打印其狀態(tài)并在8秒后休眠，而deamonthread（）函數每2秒無限期地打印hello。我們可以通過以下輸出了解nondaemon和daemon線程之間的區(qū)別
hello starting my thread hello hello hello hello ending my thread hello hello hello hello hello
Python技巧