溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
本篇內容主要講解“Python多線程怎么使用”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“Python多線程怎么使用”吧!
多線程類似于同時執行多個不同程序，多線程運行有如下優點：
使用線程可以把占據長時間的程序中的任務放到后臺去處理。
用戶界面可以更加吸引人，這樣比如用戶點擊了一個按鈕去觸發某些事件的處理，可以彈出一個進度條來顯示處理的進度
程序的運行速度可能加快
在一些等待的任務實現上如用戶輸入、文件讀寫和網絡收發數據等，線程就比較有用了。在這種情況下我們可以釋放一些珍貴的資源如內存占用等等。
線程在執行過程中與進程還是有區別的。每個獨立的進程有一個程序運行的入口、順序執行序列和程序的出口。但是線程不能夠獨立執行，必須依存在應用程序中，由應用程序提供多個線程執行控制。
每個線程都有他自己的一組CPU寄存器，稱為線程的上下文，該上下文反映了線程上次運行該線程的CPU寄存器的狀態。
指令指針和堆棧指針寄存器是線程上下文中兩個最重要的寄存器，線程總是在進程得到上下文中運行的，這些地址都用于標志擁有線程的進程地址空間中的內存。
線程可以被搶占（中斷）。
在其他線程正在運行時，線程可以暫時擱置（也稱為睡眠） -- 這就是線程的退讓。
Python中使用線程有兩種方式：函數或者用類來包裝線程對象。
函數式：調用thread模塊中的start_new_thread()函數來產生新線程。語法如下:
thread.start_new_thread ( function, args[, kwargs] )
參數說明:
function - 線程函數。
args - 傳遞給線程函數的參數,他必須是個tuple類型。
kwargs - 可選參數。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
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-1: Thu Jan 22 15:42:17 2009
Thread-1: Thu Jan 22 15:42:19 2009
Thread-2: Thu Jan 22 15:42:19 2009
Thread-1: Thu Jan 22 15:42:21 2009
Thread-2: Thu Jan 22 15:42:23 2009
Thread-1: Thu Jan 22 15:42:23 2009
Thread-1: Thu Jan 22 15:42:25 2009
Thread-2: Thu Jan 22 15:42:27 2009
Thread-2: Thu Jan 22 15:42:31 2009
Thread-2: Thu Jan 22 15:42:35 2009
線程的結束一般依靠線程函數的自然結束；也可以在線程函數中調用thread.exit()，他拋出SystemExit exception，達到退出線程的目的。
Python通過兩個標準庫thread和threading提供對線程的支持。thread提供了低級別的、原始的線程以及一個簡單的鎖。
threading 模塊提供的其他方法：
threading.currentThread(): 返回當前的線程變量。
threading.enumerate(): 返回一個包含正在運行的線程的list。正在運行指線程啟動后、結束前，不包括啟動前和終止后的線程。
threading.activeCount(): 返回正在運行的線程數量，與len(threading.enumerate())有相同的結果。
除了使用方法外，線程模塊同樣提供了Thread類來處理線程，Thread類提供了以下方法:
run(): 用以表示線程活動的方法。
start():啟動線程活動。
join([time]): 等待至線程中止。這阻塞調用線程直至線程的join() 方法被調用中止-正常退出或者拋出未處理的異常-或者是可選的超時發生。
isAlive(): 返回線程是否活動的。
getName(): 返回線程名。
setName(): 設置線程名。
使用Threading模塊創建線程，直接從threading.Thread繼承，然后重寫__init__方法和run方法：
#!/usr/bin/python # -*- coding: UTF-8 -*- import threading import time exitFlag = 0 class myThread (threading.Thread): #繼承父類threading.Thread def __init__(self, threadID, name, counter): threading.Thread.__init__(self) self.threadID = threadID self.name = name self.counter = counter def run(self): #把要執行的代碼寫到run函數里面 線程在創建后會直接運行run函數 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: (threading.Thread).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() print "Exiting Main Thread"
以上程序執行結果如下；
Starting Thread-1
Starting Thread-2
Exiting Main Thread
Thread-1: Thu Mar 21 09:10:03 2013
Thread-1: Thu Mar 21 09:10:04 2013
Thread-2: Thu Mar 21 09:10:04 2013
Thread-1: Thu Mar 21 09:10:05 2013
Thread-1: Thu Mar 21 09:10:06 2013
Thread-2: Thu Mar 21 09:10:06 2013
Thread-1: Thu Mar 21 09:10:07 2013
Exiting Thread-1
Thread-2: Thu Mar 21 09:10:08 2013
Thread-2: Thu Mar 21 09:10:10 2013
Thread-2: Thu Mar 21 09:10:12 2013
Exiting Thread-2
如果多個線程共同對某個數據修改，則可能出現不可預料的結果，為了保證數據的正確性，需要對多個線程進行同步。
使用Thread對象的Lock和Rlock可以實現簡單的線程同步，這兩個對象都有acquire方法和release方法，對于那些需要每次只允許一個線程操作的數據，可以將其操作放到acquire和release方法之間。如下：
多線程的優勢在于可以同時運行多個任務（至少感覺起來是這樣）。但是當線程需要共享數據時，可能存在數據不同步的問題。
考慮這樣一種情況：一個列表里所有元素都是0，線程"set"從后向前把所有元素改成1，而線程"print"負責從前往后讀取列表并打印。
那么，可能線程"set"開始改的時候，線程"print"便來打印列表了，輸出就成了一半0一半1，這就是數據的不同步。為了避免這種情況，引入了鎖的概念。
鎖有兩種狀態——鎖定和未鎖定。每當一個線程比如"set"要訪問共享數據時，必須先獲得鎖定；如果已經有別的線程比如"print"獲得鎖定了，那么就讓線程"set"暫停，也就是同步阻塞；等到線程"print"訪問完畢，釋放鎖以后，再讓線程"set"繼續。
經過這樣的處理，打印列表時要么全部輸出0，要么全部輸出1，不會再出現一半0一半1的尷尬場面。
#!/usr/bin/python # -*- coding: UTF-8 -*- import threading import time 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 # 獲得鎖，成功獲得鎖定后返回True # 可選的timeout參數不填時將一直阻塞直到獲得鎖定 # 否則超時后將返回False threadLock.acquire() print_time(self.name, self.counter, 3) # 釋放鎖 threadLock.release() def print_time(threadName, delay, counter): while counter: time.sleep(delay) print "%s: %s" % (threadName, time.ctime(time.time())) counter -= 1 threadLock = threading.Lock() threads = [] # 創建新線程 thread1 = myThread(1, "Thread-1", 1) thread2 = myThread(2, "Thread-2", 2) # 開啟新線程 thread1.start() thread2.start() # 添加線程到線程列表 threads.append(thread1) threads.append(thread2) # 等待所有線程完成 for t in threads: t.join() print "Exiting Main Thread"
Python的Queue模塊中提供了同步的、線程安全的隊列類，包括FIFO（先入先出)隊列Queue，LIFO（后入先出）隊列LifoQueue，和優先級隊列PriorityQueue。這些隊列都實現了鎖原語，能夠在多線程中直接使用。可以使用隊列來實現線程間的同步。
Queue模塊中的常用方法:
Queue.qsize() 返回隊列的大小
Queue.empty() 如果隊列為空，返回True,反之False
Queue.full() 如果隊列滿了，返回True,反之False
Queue.full 與 maxsize 大小對應
Queue.get([block[, timeout]])獲取隊列，timeout等待時間
Queue.get_nowait() 相當Queue.get(False)
Queue.put(item) 寫入隊列，timeout等待時間
Queue.put_nowait(item) 相當Queue.put(item, False)
Queue.task_done() 在完成一項工作之后，Queue.task_done()函數向任務已經完成的隊列發送一個信號
Queue.join() 實際上意味著等到隊列為空，再執行別的操作
#!/usr/bin/python # -*- coding: UTF-8 -*- import Queue import threading import time exitFlag = 0 class myThread (threading.Thread): def __init__(self, threadID, name, q): threading.Thread.__init__(self) self.threadID = threadID self.name = name self.q = q def run(self): print "Starting " + self.name process_data(self.name, self.q) print "Exiting " + self.name def process_data(threadName, q): while not exitFlag: queueLock.acquire() if not workQueue.empty(): data = q.get() queueLock.release() print "%s processing %s" % (threadName, data) else: queueLock.release() time.sleep(1) threadList = ["Thread-1", "Thread-2", "Thread-3"] nameList = ["One", "Two", "Three", "Four", "Five"] queueLock = threading.Lock() workQueue = Queue.Queue(10) threads = [] threadID = 1 # 創建新線程 for tName in threadList: thread = myThread(threadID, tName, workQueue) thread.start() threads.append(thread) threadID += 1 # 填充隊列 queueLock.acquire() for word in nameList: workQueue.put(word) queueLock.release() # 等待隊列清空 while not workQueue.empty(): pass # 通知線程是時候退出 exitFlag = 1 # 等待所有線程完成 for t in threads: t.join() print "Exiting Main Thread"
以上程序執行結果：
Starting Thread-1
Starting Thread-2
Starting Thread-3
Thread-1 processing One
Thread-2 processing Two
Thread-3 processing Three
Thread-1 processing Four
Thread-2 processing Five
Exiting Thread-3
Exiting Thread-1
Exiting Thread-2
Exiting Main Thread
實例擴展：
加鎖時
# -*-* encoding:UTF-8 -*- # author : shoushixiong # date : 2018/11/22 import threading import time list = [0,0,0,0,0,0,0,0,0,0,0,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 "開始線程:",self.name # 獲得鎖，成功獲得鎖定后返回 True # 可選的timeout參數不填時將一直阻塞直到獲得鎖定 # 否則超時后將返回 False threadLock.acquire() print_time(self.name,self.counter,list.__len__()) # 釋放鎖 threadLock.release() def __del__(self): print self.name,"線程結束！" def print_time(threadName,delay,counter): while counter: time.sleep(delay) list[counter-1] += 1 print "[%s] %s 修改第 %d 個值，修改后值為:%d" % (time.ctime(time.time()),threadName,counter,list[counter-1]) counter -= 1 threadLock = threading.Lock() threads = [] # 創建新線程 thread1 = myThread(1,"Thread-1",1) thread2 = myThread(2,"Thread-2",2) # 開啟新線程 thread1.start() thread2.start() # 添加線程到線程列表 threads.append(thread1) threads.append(thread2) # 等待所有線程完成 for t in threads: t.join() print "主進程結束！"
輸出結果為：
開始線程: Thread-1
開始線程: Thread-2
[Thu Nov 22 16:04:13 2018] Thread-1 修改第 12 個值，修改后值為:1
[Thu Nov 22 16:04:14 2018] Thread-1 修改第 11 個值，修改后值為:1
[Thu Nov 22 16:04:15 2018] Thread-1 修改第 10 個值，修改后值為:1
[Thu Nov 22 16:04:16 2018] Thread-1 修改第 9 個值，修改后值為:1
[Thu Nov 22 16:04:17 2018] Thread-1 修改第 8 個值，修改后值為:1
[Thu Nov 22 16:04:18 2018] Thread-1 修改第 7 個值，修改后值為:1
[Thu Nov 22 16:04:19 2018] Thread-1 修改第 6 個值，修改后值為:1
[Thu Nov 22 16:04:20 2018] Thread-1 修改第 5 個值，修改后值為:1
[Thu Nov 22 16:04:21 2018] Thread-1 修改第 4 個值，修改后值為:1
[Thu Nov 22 16:04:22 2018] Thread-1 修改第 3 個值，修改后值為:1
[Thu Nov 22 16:04:23 2018] Thread-1 修改第 2 個值，修改后值為:1
[Thu Nov 22 16:04:24 2018] Thread-1 修改第 1 個值，修改后值為:1
[Thu Nov 22 16:04:26 2018] Thread-2 修改第 12 個值，修改后值為:2
[Thu Nov 22 16:04:28 2018] Thread-2 修改第 11 個值，修改后值為:2
[Thu Nov 22 16:04:30 2018] Thread-2 修改第 10 個值，修改后值為:2
[Thu Nov 22 16:04:32 2018] Thread-2 修改第 9 個值，修改后值為:2
[Thu Nov 22 16:04:34 2018] Thread-2 修改第 8 個值，修改后值為:2
[Thu Nov 22 16:04:36 2018] Thread-2 修改第 7 個值，修改后值為:2
[Thu Nov 22 16:04:38 2018] Thread-2 修改第 6 個值，修改后值為:2
[Thu Nov 22 16:04:40 2018] Thread-2 修改第 5 個值，修改后值為:2
[Thu Nov 22 16:04:42 2018] Thread-2 修改第 4 個值，修改后值為:2
[Thu Nov 22 16:04:44 2018] Thread-2 修改第 3 個值，修改后值為:2
[Thu Nov 22 16:04:46 2018] Thread-2 修改第 2 個值，修改后值為:2
[Thu Nov 22 16:04:48 2018] Thread-2 修改第 1 個值，修改后值為:2
主進程結束！
Thread-1 線程結束！
Thread-2 線程結束！
不加鎖時
同樣是上面實例的代碼，注釋以下兩行代碼：
threadLock.acquire() threadLock.release()
輸出結果為：
開始線程: Thread-1
開始線程: Thread-2
[Thu Nov 22 16:09:20 2018] Thread-1 修改第 12 個值，修改后值為:1
[Thu Nov 22 16:09:21 2018] Thread-2 修改第 12 個值，修改后值為:2
[Thu Nov 22 16:09:21 2018] Thread-1 修改第 11 個值，修改后值為:1
[Thu Nov 22 16:09:22 2018] Thread-1 修改第 10 個值，修改后值為:1
[Thu Nov 22 16:09:23 2018] Thread-1 修改第 9 個值，修改后值為:1
[Thu Nov 22 16:09:23 2018] Thread-2 修改第 11 個值，修改后值為:2
[Thu Nov 22 16:09:24 2018] Thread-1 修改第 8 個值，修改后值為:1
[Thu Nov 22 16:09:25 2018] Thread-2 修改第 10 個值，修改后值為:2
[Thu Nov 22 16:09:25 2018] Thread-1 修改第 7 個值，修改后值為:1
[Thu Nov 22 16:09:26 2018] Thread-1 修改第 6 個值，修改后值為:1
[Thu Nov 22 16:09:27 2018] Thread-2 修改第 9 個值，修改后值為:2
[Thu Nov 22 16:09:27 2018] Thread-1 修改第 5 個值，修改后值為:1
[Thu Nov 22 16:09:28 2018] Thread-1 修改第 4 個值，修改后值為:1
[Thu Nov 22 16:09:29 2018] Thread-2 修改第 8 個值，修改后值為:2
[Thu Nov 22 16:09:29 2018] Thread-1 修改第 3 個值，修改后值為:1
[Thu Nov 22 16:09:30 2018] Thread-1 修改第 2 個值，修改后值為:1
[Thu Nov 22 16:09:31 2018] Thread-2 修改第 7 個值，修改后值為:2
[Thu Nov 22 16:09:31 2018] Thread-1 修改第 1 個值，修改后值為:1
[Thu Nov 22 16:09:33 2018] Thread-2 修改第 6 個值，修改后值為:2
[Thu Nov 22 16:09:35 2018] Thread-2 修改第 5 個值，修改后值為:2
[Thu Nov 22 16:09:37 2018] Thread-2 修改第 4 個值，修改后值為:2
[Thu Nov 22 16:09:39 2018] Thread-2 修改第 3 個值，修改后值為:2
[Thu Nov 22 16:09:41 2018] Thread-2 修改第 2 個值，修改后值為:2
[Thu Nov 22 16:09:43 2018] Thread-2 修改第 1 個值，修改后值為:2
主進程結束！
Thread-1 線程結束！
Thread-2 線程結束！
當一個線程中遇到鎖嵌套情況該怎么辦，又會遇到什么情況？
def run1():
global count1
lock.acquire()
count1 += 1
lock.release()
return count1
def run2():
global count2
lock.acquire()
count2 += 1
lock.release()
return count2
def runtask():
lock.acquire()
r1 = run1()
print("="*30)
r2 = run2()
lock.release()
print(r1,r2)
count1,count2 = 0,0
lock = threading.Lock()
for index in range(50):
t = threading.Thread(target=runtask,)
t.start()這是一個很簡單的線程鎖死案例，程序將被卡死，停止不動。為了解決這一情況，Python提供了遞歸鎖RLock(可重入鎖)。這個RLock內部維護著一個Lock和一個counter變量，counter記錄了acquire的次數，從而使得資源可以被多次require。直到一個線程所有的acquire都被release，其他的線程才能獲得資源。上面的代碼只需做一些小小的改動
到此，相信大家對“Python多線程怎么使用”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
