python 線程并發(fā)

在本章中，我們將學(xué)習(xí)如何在python中實(shí)現(xiàn)線程。

用于線程實(shí)現(xiàn)的python模塊

python線程有時被稱為輕量級進(jìn)程，因?yàn)榫€程占用的內(nèi)存比進(jìn)程少得多。線程允許一次執(zhí)行多個任務(wù)。在python中，我們有以下兩個在程序中實(shí)現(xiàn)線程的模塊

• <_thread> 模塊

• 模塊

這兩個模塊之間的主要區(qū)別在于 模塊將線程視為一個函數(shù)，而 模塊將每個線程視為一個對象，并以面向?qū)ο蟮姆绞綄?shí)現(xiàn)它。此外， < _thread>模塊在低級線程中是有效的，并且具有比< threading>模塊更少的功能。

<_thread>模塊

在早期版本的python中，我們使用了 模塊，但很長一段時間它被認(rèn)為是“已棄用”。鼓勵用戶改為使用 模塊。因此，在python 3中，模塊thread不再可用。它已被重命名為 <_thread>，以便在python3中向后兼容。

要在 <_thread>模塊的幫助下生成新線程，我們需要調(diào)用它的 start_new_thread方法。借助以下語法可以理解此方法的工作原理

_thread.start_new_thread ( function, args[, kwargs] )

在這里

• args 是一個參數(shù)元組

• kwargs 是關(guān)鍵字參數(shù)的可選字典

如果我們想在不傳遞參數(shù)的情況下調(diào)用函數(shù)，那么我們需要在 args中 使用一個空元組 參數(shù) 。

此方法調(diào)用立即返回，子線程啟動，并使用傳遞的args列表（如果有）調(diào)用函數(shù)。線程在函數(shù)返回時終止。

例

以下是使用 <_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

模塊

所述 模塊實(shí)現(xiàn)在面向?qū)ο蟮姆绞讲⒃O(shè)為每個線程作為對象。因此，它為線程提供了比<_thread>模塊更強(qiáng)大，更高級的支持。該模塊包含在python2.4中。

模塊中的其他方法

所述 模塊包括的所有方法 <_thread>模塊，但它提供了額外的方法為好。其他方法如下 -

• threading.activecount（） - 此方法返回活動的線程對象的數(shù)量

• threading.currentthread（） - 此方法返回調(diào)用者線程控件中的線程對象數(shù)。

• threading.enumerate（） - 此方法返回當(dāng)前活動的所有線程對象的列表。

為了實(shí)現(xiàn)線程， 模塊有 thread 類，它提供以下方法

* run（） \- run（）方法是線程的入口點(diǎn)。

* start（） \- start（）方法通過調(diào)用run方法啟動一個線程。

* join（[time]） \- join（）等待線程終止。

* isalive（） \- isalive（）方法檢查線程是否仍在執(zhí)行。

* getname（） \- getname（）方法返回線程的名稱。

* setname（） \- setname（）方法設(shè)置線程的名稱。

如何使用模塊創(chuàng)建線程？

在本節(jié)中，我們將學(xué)習(xí)如何使用 模塊創(chuàng)建線程。按照以下步驟使用模塊創(chuàng)建新線程

• 第1步 - 在這一步中，我們需要定義 thread 類的新子類。

• 第2步 - 然后，為了添加其他參數(shù)，我們需要覆蓋 __init __（self [，args]） 方法。

• 第3步 - 在這一步中，我們需要覆蓋run（self [，args]）方法來實(shí)現(xiàn)線程在啟動時應(yīng)該做的事情。

現(xiàn)在，在創(chuàng)建新的 thread 子類之后，我們可以創(chuàng)建它的一個實(shí)例，然后通過調(diào)用 start（） 啟動一個新線程， start（） 又調(diào)用 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

輸出

現(xiàn)在，考慮以下輸出

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) - 新的，可運(yùn)行的，運(yùn)行的，等待的和死的。在這五個中，我們主要關(guān)注三個州 跑步，等待和死亡。線程將其資源置于運(yùn)行狀態(tài)，等待處于等待狀態(tài)的資源; 資源的最終版本，如果執(zhí)行和獲取處于死亡狀態(tài)。

以下python程序在start（），sleep（）和join（）方法的幫助下將分別顯示線程如何進(jìn)入running，waiting和dead狀態(tài)。

步驟1 - 導(dǎo)入必要的模塊， 和

import threading
import time

第2步 - 定義一個函數(shù)，在創(chuàng)建線程時將調(diào)用該函數(shù)。

def thread_states():
   print("thread entered in running state")

第3步 - 我們使用time模塊的sleep（）方法讓我們的線程等待2秒鐘。

time.sleep(2)

第4步 - 現(xiàn)在，我們創(chuàng)建一個名為t1的線程，它接受上面定義的函數(shù)的參數(shù)。

t1 = threading.thread(target=thread_states)

第5步 - 現(xiàn)在，在start（）函數(shù)的幫助下，我們可以啟動我們的線程。 它將生成消息，該消息由我們在定義函數(shù)時設(shè)置。

t1.start()
thread entered in running state

第6步 - 現(xiàn)在，最后我們可以在完成執(zhí)行后使用join（）方法終止該線程。

t1.join()

在python中啟動一個線程

在python中，我們可以通過不同的方式啟動一個新線程，但其中最簡單的一個是將它定義為單個函數(shù)。定義函數(shù)后，我們可以將其作為新的 threading.thread 對象的目標(biāo)傳遞。執(zhí)行以下python代碼以了解該函數(shù)的工作原理

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中的守護(hù)程序線程

在python中實(shí)現(xiàn)守護(hù)程序線程之前，我們需要了解守護(hù)程序線程及其用法。在計算方面，守護(hù)進(jìn)程是一個后臺進(jìn)程，它處理各種服務(wù)的請求，例如數(shù)據(jù)發(fā)送，文件傳輸?shù)?。如果不再需要它，它將處于休眠狀態(tài)。同樣的任務(wù)也可以在非守護(hù)程序線程的幫助下完成。但是，在這種情況下，主線程必須手動跟蹤非守護(hù)程序線程。另一方面，如果我們使用守護(hù)程序線程，那么主線程可以完全忘記這一點(diǎn)，它將在主線程退出時被終止。關(guān)于守護(hù)程序線程的另一個重要觀點(diǎn)是，我們可以選擇僅將它們用于非必要任務(wù)，如果它們沒有完成或在它們之間被殺死則不會影響我們。以下是python中守護(hù)程序線程的實(shí)現(xiàn)

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

在上面的代碼中，有兩個函數(shù)，即 nondaemonthread（） 和 daemonthread（） 。第一個函數(shù)打印其狀態(tài)并在8秒后休眠，而deamonthread（）函數(shù)每2秒無限期地打印hello。我們可以通過以下輸出了解nondaemon和daemon線程之間的區(qū)別

hello

starting my thread
hello
hello
hello
hello
ending my thread
hello
hello
hello
hello
hello