快捷導(dǎo)航

python多線程使用方法實例詳解

更新時間：2019年12月30日 10:12:23 作者：雪山飛豬

這篇文章主要介紹了python多線程使用方法,結(jié)合實例形式詳細(xì)分析了Python多線程thread模塊、鎖機制相關(guān)使用技巧與操作注意事項,需要的朋友可以參考下

本文實例講述了python多線程使用方法。分享給大家供大家參考，具體如下：

threading 模塊支持守護線程，其工作方式是：守護線程一般是一個等待客戶端請求服務(wù)的服務(wù)器。

如果把一個線程設(shè)置為守護線程，進程退出時不需要等待這個線程執(zhí)行完成。

如果主線程準(zhǔn)備退出時，不需要等待某些子線程完成，就可以為這些子線程設(shè)置守護線程標(biāo)記。需要在啟動線程之前執(zhí)行如下賦值語句： thread.daemon = True，檢查線程的守護狀態(tài)也只需要檢查這個值即可。

整個 Python 程序?qū)⒃谒蟹鞘刈o線程退出之后才退出，換句話說，就是沒有剩下存活的非守護線程時才退出。

使用thread模塊

以下是三種使用 Thread 類的方法(一般使用第一個或第三個方案)

創(chuàng)建 Thread 的實例，傳給它一個函數(shù)。

import threading
from time import sleep, ctime
loops = [3, 2, 1, 1, 1]
def loop(i, nsec):
  print(f'start loop {i} at: {ctime()}')
  sleep(nsec)
  print(f'end loop {i} at: {ctime()}')
def main():
  print('start at', ctime())
  threads = []
  nloops = range(len(loops))
  for i in nloops:
    t = threading.Thread(target=loop, args=(i, loops[i]))
    threads.append(t)
  for i in nloops: # start threads
    threads[i].start()
  for i in nloops: # wait for all
    threads[i].join() # threads to finish
  print(f'all done at: {ctime()}')
if __name__ == '__main__':
  main()

當(dāng)所有線程都分配完成之后，通過調(diào)用每個線程的 start()方法讓它們開始執(zhí)行，而不是在這之前就會執(zhí)行。
相比于管理一組鎖（分配、獲取、釋放、檢查鎖狀態(tài)等）而言，這里只需要為每個線程調(diào)用 join()方法即可。
join()方法將等待線程結(jié)束，或者在提供了超時時間的情況下，達到超時時間。
使用 join()方法要比等待鎖釋放的無限循環(huán)更加清晰（這也是這種鎖又稱為自旋鎖的原因）。

創(chuàng)建 Thread 的實例，傳給它一個可調(diào)用的類實例。

import threading
from time import sleep, ctime
# 創(chuàng)建 Thread 的實例，傳給它一個可調(diào)用的類實例
loops = [3, 2, 1, 1, 1]
class ThreadFunc(object):
  def __init__(self, func, args, name=''):
    self.name = name
    self.func = func
    self.args = args
  def __call__(self):
    self.func(*self.args)
def loop(i, nsec):
  print(f'start loop {i} at: {ctime()}')
  sleep(nsec)
  print(f'end loop {i} at: {ctime()}')
def main():
  print('start at', ctime())
  threads = []
  nloops = range(len(loops))
  for i in nloops:
    t = threading.Thread(target=ThreadFunc(loop, (i, loops[i]), loop.__name__))
    threads.append(t)
  for i in nloops: # start threads
    threads[i].start()
  for i in nloops: # wait for all
    threads[i].join() # threads to finish
  print(f'all done at: {ctime()}')
if __name__ == '__main__':
  main()

派生 Thread 的子類，并創(chuàng)建子類的實例。

import threading
from time import sleep, ctime
# 創(chuàng)建 Thread 的實例，傳給它一個可調(diào)用的類實例
# 子類的構(gòu)造函數(shù)必須先調(diào)用其基類的構(gòu)造函數(shù)
# 特殊方法__call__()在 子類中必須要寫為 run()
loops = [3, 2, 1, 1, 1]
class MyThread(threading.Thread):
  def __init__(self, func, args, name=''):
    threading.Thread.__init__(self)
    self.name = name
    self.func = func
    self.args = args
  def run(self):
    self.func(*self.args)
def loop(i, nsec):
  print(f'start loop {i} at: {ctime()}')
  sleep(nsec)
  print(f'end loop {i} at: {ctime()}')
def main():
  print('start at', ctime())
  threads = []
  nloops = range(len(loops))
  for i in nloops:
    t = MyThread(loop, (i, loops[i]), loop.__name__)
    threads.append(t)
  for i in nloops: # start threads
    threads[i].start()
  for i in nloops: # wait for all
    threads[i].join() # threads to finish
  print(f'all done at: {ctime()}')
if __name__ == '__main__':
  main()

使用鎖

python和java一樣，也具有鎖機制，而且創(chuàng)建與使用鎖都是很簡便的。

一般在多線程代碼中，總會有一些特定的函數(shù)或代碼塊不希望（或不應(yīng)該）被多個線程同時執(zhí)行，通常包括修改數(shù)據(jù)庫、更新文件或其他會產(chǎn)生競態(tài)條件的類似情況

鎖有兩種狀態(tài)：鎖定和未鎖定。而且它也只支持兩個函數(shù)：獲得鎖和釋放鎖。

一般鎖的調(diào)用如下

# 加載線程的鎖對象
lock = threading.Lock()
# 獲取鎖
lock.acquire()
# ...代碼
# 釋放鎖
lock.release()

更簡潔的方法是使用with關(guān)鍵字，如下代碼功能同上

# 加載線程的鎖對象
lock = threading.Lock()
with lock :
  #...代碼

示例代碼：

import threading
from time import sleep, ctime
lock = threading.Lock()
def a():
  lock.acquire()
  for x in range(5):
    print(f'a:{str(x)}')
    sleep(0.01)
  lock.release()
def b():
  lock.acquire()
  for x in range(5):
    print(f'a:{str(x)}')
    sleep(0.01)
  lock.release()
threading.Thread(target=a).start()
threading.Thread(target=b).start()

相關(guān)屬性和方法

Thread對象的屬性

屬性	描述
name	線程名
ident	線程的標(biāo)識符
daemon	布爾標(biāo)志，表示這個線程是否是守護線程

Thread對象的方法

方法	描述
init(group=None, tatget=None, name=None, args=(), kwargs ={}, verbose=None, daemon=None)	實例化一個線程對象，需要有一個可調(diào)用的 target，以及其參數(shù) args 或 kwargs。還可以傳遞 name 或 group 參數(shù)，不過后者還未實現(xiàn)。此外， verbose 標(biāo) 志也是可接受的。而 daemon 的值將會設(shè) 定 thread.daemon 屬性/標(biāo)志
start()	開始執(zhí)行該線程
run()	定義線程功能的方法（通常在子類中被應(yīng)用開發(fā)者重寫）
join (timeout=None)	直至啟動的線程終止之前一直掛起；除非給出了 timeout（秒），否則會一直阻塞
is_alive()	布爾標(biāo)志，表示這個線程是否還存活

threading模塊其他函數(shù)

函數(shù)	描述
start()	開始執(zhí)行該線程
active_count()	當(dāng)前活動的 Thread 對象個數(shù)
enumerate()	返回當(dāng)前活動的 Thread 對象列表
settrace(func)	為所有線程設(shè)置一個 trace 函數(shù)
setprofile (func)	為所有線程設(shè)置一個 profile 函數(shù)
stack_size(size=0)	返回新創(chuàng)建線程的棧大小；或為后續(xù)創(chuàng)建的線程設(shè)定棧的大小為 size
Lock()	加載線程的鎖對象，是一個基本的鎖對象，一次只能一個鎖定，其余鎖請求，需等待鎖釋放后才能獲取,對象有acquire()和release()方法
RLock()	多重鎖，在同一線程中可用被多次acquire。如果使用RLock，那么acquire和release必須成對出現(xiàn)，調(diào)用了n次acquire鎖請求，則必須調(diào)用n次的release才能在線程中釋放鎖對象

后記

在Python多線程下，每個線程的執(zhí)行方式：

1、獲取GIL
2、執(zhí)行代碼直到sleep或者是python虛擬機將其掛起。
3、釋放GIL

通常來說，多線程是一個好東西。不過由于 Python 的 GIL 的限制，多線程更適合于 I/O 密集型應(yīng)用（I/O 釋放了 GIL，可以允許更多的并發(fā)），而不是計算密集型應(yīng)用。對于后一種情況而言，為了實現(xiàn)更好的并行性，你需要使用多進程，以便讓 CPU 的其他內(nèi)核來執(zhí)行。

請注意：多核多線程比單核多線程更差，原因是單核下多線程，每次釋放GIL，喚醒的那個線程都能獲取到GIL鎖，所以能夠無縫執(zhí)行，但多核下，CPU0釋放GIL后，其他CPU上的線程都會進行競爭，但GIL可能會馬上又被CPU0拿到，導(dǎo)致其他幾個CPU上被喚醒后的線程會醒著等待到切換時間后又進入待調(diào)度狀態(tài)，這樣會造成線程顛簸(thrashing)，導(dǎo)致效率更低

更多關(guān)于Python相關(guān)內(nèi)容感興趣的讀者可查看本站專題：《Python進程與線程操作技巧總結(jié)》、《Python數(shù)據(jù)結(jié)構(gòu)與算法教程》、《Python函數(shù)使用技巧總結(jié)》、《Python字符串操作技巧匯總》、《Python入門與進階經(jīng)典教程》、《Python+MySQL數(shù)據(jù)庫程序設(shè)計入門教程》及《Python常見數(shù)據(jù)庫操作技巧匯總》

希望本文所述對大家Python程序設(shè)計有所幫助。

您可能感興趣的文章: