當前位置:首頁 » 編程語言 » python多線程threading

python多線程threading

發布時間: 2022-10-04 12:36:05

python多線程的幾種方法

Python進階(二十六)-多線程實現同步的四種方式
臨界資源即那些一次只能被一個線程訪問的資源,典型例子就是列印機,它一次只能被一個程序用來執行列印功能,因為不能多個線程同時操作,而訪問這部分資源的代碼通常稱之為臨界區。
鎖機制
threading的Lock類,用該類的acquire函數進行加鎖,用realease函數進行解鎖
import threadingimport timeclass Num:
def __init__(self):
self.num = 0
self.lock = threading.Lock() def add(self):
self.lock.acquire()#加鎖,鎖住相應的資源
self.num += 1
num = self.num
self.lock.release()#解鎖,離開該資源
return num

n = Num()class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item def run(self):
time.sleep(2)
value = n.add()#將num加1,並輸出原來的數據和+1之後的數據
print(self.item,value)for item in range(5):
t = jdThread(item)
t.start()
t.join()#使線程一個一個執行

當一個線程調用鎖的acquire()方法獲得鎖時,鎖就進入「locked」狀態。每次只有一個線程可以獲得鎖。如果此時另一個線程試圖獲得這個鎖,該線程就會變為「blocked」狀態,稱為「同步阻塞」(參見多線程的基本概念)。
直到擁有鎖的線程調用鎖的release()方法釋放鎖之後,鎖進入「unlocked」狀態。線程調度程序從處於同步阻塞狀態的線程中選擇一個來獲得鎖,並使得該線程進入運行(running)狀態。
信號量
信號量也提供acquire方法和release方法,每當調用acquire方法的時候,如果內部計數器大於0,則將其減1,如果內部計數器等於0,則會阻塞該線程,知道有線程調用了release方法將內部計數器更新到大於1位置。
import threadingimport timeclass Num:
def __init__(self):
self.num = 0
self.sem = threading.Semaphore(value = 3) #允許最多三個線程同時訪問資源

def add(self):
self.sem.acquire()#內部計數器減1
self.num += 1
num = self.num
self.sem.release()#內部計數器加1
return num

n = Num()class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item def run(self):
time.sleep(2)
value = n.add()
print(self.item,value)for item in range(100):

⑵ python中的多線程為什麼會報錯

題主你好,
你的問題在於threading模式的Thread()類使用的不正確,你代碼中的代碼為:
t1 = threading.Thread(target=name_b, name="job2")
其中name_b是你定義的函數名, 其實光看語句本身是沒錯的,但問題出在:
" name_b這個函數定義中有兩個參數,你沒有在Thread()類中給name_b傳參 "
你想一下,如果不考慮多線程,你去調用name_b這個函數,光寫個:
name_b() 肯定是不對的
你要將os_name2和url_b這兩個參數也帶上才行,即:
name_b(xxx, yyy)

所以就你當前代碼報錯信息要改的話, 只需要在兩個threading.Thread()中再加一個args參數,將傳給函數的參數代碼寫在" () "中, 即:
threading.Thread(target=name_b, name="job2", args=(xxx, yyy))
另一個threading.Thread()你照著上面的寫即可.
希望可以幫到題主, 歡迎追問

⑶ Python面試題,線程與進程的區別,Python中如何創建多線程

進程和線程

這兩個概念屬於操作系統,我們經常聽說,但是可能很少有人會細究它們的含義。對於工程師而言,兩者的定義和區別還是很有必要了解清楚的。

首先說進程,進程可以看成是 CPU執行的具體的任務 。在操作系統當中,由於CPU的運行速度非常快,要比計算機當中的其他設備要快得多。比如內存、磁碟等等,所以如果CPU一次只執行一個任務,那麼會導致CPU大量時間在等待這些設備,這樣操作效率很低。為了提升計算機的運行效率,把機器的技能盡可能壓榨出來,CPU是輪詢工作的。也就是說 它一次只執行一個任務,執行一小段碎片時間之後立即切換 ,去執行其他任務。

所以在早期的單核機器的時候,看起來電腦也是並發工作的。我們可以一邊聽歌一邊上網,也不會覺得卡頓。但實際上,這是CPU輪詢的結果。在這個例子當中,聽歌的軟體和上網的軟體對於CPU而言都是 獨立的進程 。我們可以把進程簡單地理解成運行的應用,比如在安卓手機裡面,一個app啟動的時候就會對應系統中的一個進程。當然這種說法不完全准確, 一個應用也是可以啟動多個進程的

進程是對應CPU而言的,線程則更多針對的是程序。即使是CPU在執行當前進程的時候,程序運行的任務其實也是有分工的。舉個例子,比如聽歌軟體當中,我們需要顯示歌詞的字幕,需要播放聲音,需要監聽用戶的行為,比如是否發生了切歌、調節音量等等。所以,我們需要 進一步拆分CPU的工作 ,讓它在執行當前進程的時候,繼續通過輪詢的方式來同時做多件事情。

進程中的任務就是線程,所以從這點上來說, 進程和線程是包含關系 。一個進程當中可以包含多個線程,對於CPU而言,不能直接執行線程,一個線程一定屬於一個進程。所以我們知道,CPU進程切換切換的是執行的應用程序或者是軟體,而進程內部的線程切換,切換的是軟體當中具體的執行任務。

關於進程和線程有一個經典的模型可以說明它們之間的關系,假設CPU是一家工廠,工廠當中有多個車間。不同的車間對應不同的生產任務,有的車間生產汽車輪胎,有的車間生產汽車骨架。但是工廠的電力是有限的,同時只能滿足一個廠房的使用。

為了讓大家的進度協調,所以工廠需要輪流提供各個車間的供電。 這里的車間對應的就是進程

一個車間雖然只生產一種產品,但是其中的工序卻不止一個。一個車間可能會有好幾條流水線,具體的生產任務其實是流水線完成的,每一條流水線對應一個具體執行的任務。但是同樣的, 車間同一時刻也只能執行一條流水線 ,所以我們需要車間在這些流水線之間切換供電,讓各個流水線生產進度統一。

這里車間里的 流水線自然對應的就是線程的概念 ,這個模型很好地詮釋了CPU、進程和線程之間的關系。實際的原理也的確如此,不過CPU中的情況要比現實中的車間復雜得多。因為對於進程和CPU來說,它們面臨的局面都是實時變化的。車間當中的流水線是x個,下一刻可能就成了y個。

了解完了線程和進程的概念之後,對於理解電腦的配置也有幫助。比如我們買電腦,經常會碰到一個術語,就是這個電腦的CPU是某某核某某線程的。比如我當年買的第一台筆記本是4核8線程的,這其實是在說這台電腦的CPU有 4個計算核心 ,但是使用了超線程技術,使得可以把一個物理核心模擬成兩個邏輯核心。相當於我們可以用4個核心同時執行8個線程,相當於8個核心同時執行,但其實有4個核心是模擬出來的虛擬核心。

有一個問題是 為什麼是4核8線程而不是4核8進程呢 ?因為CPU並不會直接執行進程,而是執行的是進程當中的某一個線程。就好像車間並不能直接生產零件,只有流水線才能生產零件。車間負責的更多是資源的調配,所以教科書里有一句非常經典的話來詮釋: 進程是資源分配的最小單元,線程是CPU調度的最小單元

啟動線程

Python當中為我們提供了完善的threading庫,通過它,我們可以非常方便地創建線程來執行多線程。

首先,我們引入threading中的Thread,這是一個線程的類,我們可以通過創建一個線程的實例來執行多線程。

from threading import Thread t = Thread(target=func, name='therad', args=(x, y)) t.start()

簡單解釋一下它的用法,我們傳入了三個參數,分別是 target,name和args ,從名字上我們就可以猜測出它們的含義。首先是target,它傳入的是一個方法,也就是我們希望多線程執行的方法。name是我們為這個新創建的線程起的名字,這個參數可以省略,如果省略的話,系統會為它起一個系統名。當我們執行Python的時候啟動的線程名叫MainThread,通過線程的名字我們可以做區分。args是會傳遞給target這個函數的參數。

我們來舉個經典的例子:

import time, threading # 新線程執行的代碼: def loop(n): print('thread %s is running...' % threading.current_thread().name) for i in range(n): print('thread %s >>> %s' % (threading.current_thread().name, i)) time.sleep(5) print('thread %s ended.' % threading.current_thread().name) print('thread %s is running...' % threading.current_thread().name) t = threading.Thread(target=loop, name='LoopThread', args=(10, )) t.start() print('thread %s ended.' % threading.current_thread().name)

我們創建了一個非常簡單的loop函數,用來執行一個循環來列印數字,我們每次列印一個數字之後這個線程會睡眠5秒鍾,所以我們看到的結果應該是每過5秒鍾屏幕上多出一行數字。

我們在Jupyter里執行一下:

表面上看這個結果沒毛病,但是其實有一個問題,什麼問題呢? 輸出的順序不太對 ,為什麼我們在列印了第一個數字0之後,主線程就結束了呢?另外一個問題是,既然主線程已經結束了, 為什麼Python進程沒有結束 , 還在向外列印結果呢?

因為線程之間是獨立的,對於主線程而言,它在執行了t.start()之後,並 不會停留,而是會一直往下執行一直到結束 。如果我們不希望主線程在這個時候結束,而是阻塞等待子線程運行結束之後再繼續運行,我們可以在代碼當中加上t.join()這一行來實現這點。

t.start() t.join() print('thread %s ended.' % threading.current_thread().name)

join操作可以讓主線程在join處掛起等待,直到子線程執行結束之後,再繼續往下執行。我們加上了join之後的運行結果是這樣的:

這個就是我們預期的樣子了,等待子線程執行結束之後再繼續。

我們再來看第二個問題,為什麼主線程結束的時候,子線程還在繼續運行,Python進程沒有退出呢?這是因為默認情況下我們創建的都是用戶級線程,對於進程而言, 會等待所有用戶級線程執行結束之後才退出 。這里就有了一個問題,那假如我們創建了一個線程嘗試從一個介面當中獲取數據,由於介面一直沒有返回,當前進程豈不是會永遠等待下去?

這顯然是不合理的,所以為了解決這個問題,我們可以把創建出來的線程設置成 守護線程

守護線程

守護線程即daemon線程,它的英文直譯其實是後台駐留程序,所以我們也可以理解成 後台線程 ,這樣更方便理解。daemon線程和用戶線程級別不同,進程不會主動等待daemon線程的執行, 當所有用戶級線程執行結束之後即會退出。進程退出時會kill掉所有守護線程

我們傳入daemon=True參數來將創建出來的線程設置成後台線程:

t = threading.Thread(target=loop, name='LoopThread', args=(10, ), daemon=True)

這樣我們再執行看到的結果就是這樣了:

這里有一點需要注意,如果你 在jupyter當中運行是看不到這樣的結果的 。因為jupyter自身是一個進程,對於jupyter當中的cell而言,它一直是有用戶級線程存活的,所以進程不會退出。所以想要看到這樣的效果,只能通過命令行執行Python文件。

如果我們想要等待這個子線程結束,就必須通過join方法。另外,為了預防子線程鎖死一直無法退出的情況, 我們還可以 在joih當中設置timeout ,即最長等待時間,當等待時間到達之後,將不再等待。

比如我在join當中設置的timeout等於5時,屏幕上就只會輸出5個數字。

另外,如果沒有設置成後台線程的話,設置timeout雖然也有用,但是 進程仍然會等待所有子線程結束 。所以屏幕上的輸出結果會是這樣的:

雖然主線程繼續往下執行並且結束了,但是子線程仍然一直運行,直到子線程也運行結束。

關於join設置timeout這里有一個坑,如果我們只有一個線程要等待還好,如果有多個線程,我們用一個循環將它們設置等待的話。那麼 主線程一共會等待N * timeout的時間 ,這里的N是線程的數量。因為每個線程計算是否超時的開始時間是上一個線程超時結束的時間,它會等待所有線程都超時,才會一起終止它們。

比如我這樣創建3個線程:

ths = [] for i in range(3): t = threading.Thread(target=loop, name='LoopThread' + str(i), args=(10, ), daemon=True) ths.append(t) for t in ths: t.start() for t in ths: t.join(2)

最後屏幕上輸出的結果是這樣的:

所有線程都存活了6秒。

總結

在今天的文章當中,我們一起簡單了解了 操作系統當中線程和進程的概念 ,以及Python當中如何創建一個線程,以及關於創建線程之後的相關使用。

多線程在許多語言當中都是至關重要的,許多場景下必定會使用到多線程。比如 web後端,比如爬蟲,再比如游戲開發 以及其他所有需要涉及開發ui界面的領域。因為凡是涉及到ui,必然會需要一個線程單獨渲染頁面,另外的線程負責准備數據和執行邏輯。因此,多線程是專業程序員繞不開的一個話題,也是一定要掌握的內容之一。

⑷ python 多線程和多進程的區別 mutiprocessing theading

在socketserver服務端代碼中有這么一句:

server = socketserver.ThreadingTCPServer((ip,port), MyServer)

ThreadingTCPServer這個類是一個支持多線程和TCP協議的socketserver,它的繼承關系是這樣的:

class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass

右邊的TCPServer實際上是主要的功能父類,而左邊的ThreadingMixIn則是實現了多線程的類,ThreadingTCPServer自己本身則沒有任何代碼。

MixIn在Python的類命名中很常見,稱作「混入」,戲稱「亂入」,通常為了某種重要功能被子類繼承。

我們看看一下ThreadingMixIn的源代碼:

class ThreadingMixIn:

daemon_threads = False

def process_request_thread(self, request, client_address):
try:
self.finish_request(request, client_address)
self.shutdown_request(request)
except:
self.handle_error(request, client_address)
self.shutdown_request(request)

def process_request(self, request, client_address):

t = threading.Thread(target = self.process_request_thread,
args = (request, client_address))
t.daemon = self.daemon_threads
t.start()

在ThreadingMixIn類中,其實就定義了一個屬性,兩個方法。其中的process_request()方法實際調用的正是Python內置的多線程模塊threading。這個模塊是Python中所有多線程的基礎,socketserver本質上也是利用了這個模塊。

socketserver通過threading模塊,實現了多線程任務處理能力,可以同時為多個客戶提供服務。

那麼,什麼是線程,什麼是進程?

進程是程序(軟體,應用)的一個執行實例,每個運行中的程序,可以同時創建多個進程,但至少要有一個。每個進程都提供執行程序所需的所有資源,都有一個虛擬的地址空間、可執行的代碼、操作系統的介面、安全的上下文(記錄啟動該進程的用戶和許可權等等)、唯一的進程ID、環境變數、優先順序類、最小和最大的工作空間(內存空間)。進程可以包含線程,並且每個進程必須有至少一個線程。每個進程啟動時都會最先產生一個線程,即主線程,然後主線程會再創建其他的子線程。

線程,有時被稱為輕量級進程(Lightweight Process,LWP),是程序執行流的最小單元。一個標準的線程由線程ID,當前指令指針(PC),寄存器集合和堆棧組成。另外,線程是進程中的一個實體,是被系統獨立調度和分派的基本單位,線程自己不獨立擁有系統資源,但它可與同屬一個進程的其它線程共享該進程所擁有的全部資源。每一個應用程序都至少有一個進程和一個線程。在單個程序中同時運行多個線程完成不同的被劃分成一塊一塊的工作,稱為多線程。

舉個例子,某公司要生產一種產品,於是在生產基地建設了很多廠房,每個廠房內又有多條流水生產線。所有廠房配合將整個產品生產出來,單個廠房內的流水線負責生產所屬廠房的產品部件,每個廠房都擁有自己的材料庫,廠房內的生產線共享這些材料。公司要實現生產必須擁有至少一個廠房一條生產線。換成計算機的概念,那麼這家公司就是應用程序,廠房就是應用程序的進程,生產線就是某個進程的一個線程。

線程的特點:

線程是一個execution context(執行上下文),即一個cpu執行時所需要的一串指令。假設你正在讀一本書,沒有讀完,你想休息一下,但是你想在回來時繼續先前的進度。有一個方法就是記下頁數、行數與字數這三個數值,這些數值就是execution context。如果你的室友在你休息的時候,使用相同的方法讀這本書。你和她只需要這三個數字記下來就可以在交替的時間共同閱讀這本書了。

線程的工作方式與此類似。CPU會給你一個在同一時間能夠做多個運算的幻覺,實際上它在每個運算上只花了極少的時間,本質上CPU同一時刻只能幹一件事,所謂的多線程和並發處理只是假象。CPU能這樣做是因為它有每個任務的execution context,就像你能夠和你朋友共享同一本書一樣。

進程與線程區別:

  • 同一個進程中的線程共享同一內存空間,但進程之間的內存空間是獨立的。

  • 同一個進程中的所有線程的數據是共享的,但進程之間的數據是獨立的。

  • 對主線程的修改可能會影響其他線程的行為,但是父進程的修改(除了刪除以外)不會影響其他子進程。

  • 線程是一個上下文的執行指令,而進程則是與運算相關的一簇資源。

  • 同一個進程的線程之間可以直接通信,但是進程之間的交流需要藉助中間代理來實現。

  • 創建新的線程很容易,但是創建新的進程需要對父進程做一次復制。

  • 一個線程可以操作同一進程的其他線程,但是進程只能操作其子進程。

  • 線程啟動速度快,進程啟動速度慢(但是兩者運行速度沒有可比性)。

  • 由於現代cpu已經進入多核時代,並且主頻也相對以往大幅提升,多線程和多進程編程已經成為主流。Python全面支持多線程和多進程編程,同時還支持協程。

⑸ python threadingd多線程老是出錯

把你的代碼執行了一下,應該是有兩個地方有問題。

1、入參(u'颯颯',)這個改成(u'颯颯'.encode("utf-8"),)

2、t2=threading.Thread(target=movie,args=(u'問問')),這個地方改成

t2=threading.Thread(target=movie,args=(u'問問',))。不然會當成兩個參數。


3、第三個不確定你的用途。就是t.setDaemon(True)那個地方。調用setDaemon的時候,子線程會隨著主線程一起結束,不管子線程是否執行完成。所以有時候會出現執行完了啥輸出都沒有的情況。如果想讓主線程等待子線程,在start後面使用t.join()。這樣就會一直都有輸出了。


修改完如下:

#coding=utf-8
importthreading
fromtimeimportctime

defmusic(m):
print'在聽%s,現在是%s'%(m,ctime())

defmovie(mo):
print'在看%s,現在是%s'%(mo,ctime())

threadList=[]
t1=threading.Thread(target=music,args=(u'颯颯'.encode("utf-8"),))
threadList.append(t1)

t2=threading.Thread(target=movie,args=(u'問問'.encode("utf-8")))
threadList.append(t2)

fortinthreadList:
t.setDaemon(True)
t.start()
#t.join()

⑹ 請教python如何開啟多線程

可以定義函數把這些代碼放在不同的函數里,然後threading模塊
import threading
th1 = threading.Thread(target=func1, args=(arg1, arg2, ...))
照這樣再定義別的線程,開啟用Thread類的start方法
th1.start(); th2.start(); ...

⑺ Python多線程總結

在實際處理數據時,因系統內存有限,我們不可能一次把所有數據都導出進行操作,所以需要批量導出依次操作。為了加快運行,我們會採用多線程的方法進行數據處理, 以下為我總結的多線程批量處理數據的模板:

主要分為三大部分:


共分4部分對多線程的內容進行總結。

先為大家介紹線程的相關概念:

在飛車程序中,如果沒有多線程,我們就不能一邊聽歌一邊玩飛車,聽歌與玩 游戲 不能並行;在使用多線程後,我們就可以在玩 游戲 的同時聽背景音樂。在這個例子中啟動飛車程序就是一個進程,玩 游戲 和聽音樂是兩個線程。

Python 提供了 threading 模塊來實現多線程:

因為新建線程系統需要分配資源、終止線程系統需要回收資源,所以如果可以重用線程,則可以減去新建/終止的開銷以提升性能。同時,使用線程池的語法比自己新建線程執行線程更加簡潔。

Python 為我們提供了 ThreadPoolExecutor 來實現線程池,此線程池默認子線程守護。它的適應場景為突發性大量請求或需要大量線程完成任務,但實際任務處理時間較短。

其中 max_workers 為線程池中的線程個數,常用的遍歷方法有 map 和 submit+as_completed 。根據業務場景的不同,若我們需要輸出結果按遍歷順序返回,我們就用 map 方法,若想誰先完成就返回誰,我們就用 submit+as_complete 方法。

我們把一個時間段內只允許一個線程使用的資源稱為臨界資源,對臨界資源的訪問,必須互斥的進行。互斥,也稱間接制約關系。線程互斥指當一個線程訪問某臨界資源時,另一個想要訪問該臨界資源的線程必須等待。當前訪問臨界資源的線程訪問結束,釋放該資源之後,另一個線程才能去訪問臨界資源。鎖的功能就是實現線程互斥。

我把線程互斥比作廁所包間上大號的過程,因為包間里只有一個坑,所以只允許一個人進行大號。當第一個人要上廁所時,會將門上上鎖,這時如果第二個人也想大號,那就必須等第一個人上完,將鎖解開後才能進行,在這期間第二個人就只能在門外等著。這個過程與代碼中使用鎖的原理如出一轍,這里的坑就是臨界資源。 Python 的 threading 模塊引入了鎖。 threading 模塊提供了 Lock 類,它有如下方法加鎖和釋放鎖:

我們會發現這個程序只會列印「第一道鎖」,而且程序既沒有終止,也沒有繼續運行。這是因為 Lock 鎖在同一線程內第一次加鎖之後還沒有釋放時,就進行了第二次 acquire 請求,導致無法執行 release ,所以鎖永遠無法釋放,這就是死鎖。如果我們使用 RLock 就能正常運行,不會發生死鎖的狀態。

在主線程中定義 Lock 鎖,然後上鎖,再創建一個子 線程t 運行 main 函數釋放鎖,結果正常輸出,說明主線程上的鎖,可由子線程解鎖。

如果把上面的鎖改為 RLock 則報錯。在實際中設計程序時,我們會將每個功能分別封裝成一個函數,每個函數中都可能會有臨界區域,所以就需要用到 RLock 。

一句話總結就是 Lock 不能套娃, RLock 可以套娃; Lock 可以由其他線程中的鎖進行操作, RLock 只能由本線程進行操作。

⑻ python threading 多線程怎麼用

使用threading.Thread(),實例化一個線程
#-*-coding:utf-8-*-
importthreading

#使用threading.Thread(),實例化一個線程
defT():
printthreading.current_thread().getName()

#創建線程對象
t1=threading.Thread(target=T,name='tt11')
#啟動線程
t1.start()
t1.join()

⑼ python 怎麼實現多線程的

線程也就是輕量級的進程,多線程允許一次執行多個線程,Python是多線程語言,它有一個多線程包,GIL也就是全局解釋器鎖,以確保一次執行單個線程,一個線程保存GIL並在將其傳遞給下一個線程之前執行一些操作,也就產生了並行執行的錯覺。

⑽ python 循環中使用多線程

import time
import threading
def p(*listp):
for i in range(0,len(listp)):
print (listp[i])
p1=[]
p2=[]
for i in range(1,100):
if(i%10==1):
p1.append(i)
elif(i%10==2):
p2.append(i)
threads=[]
th1=threading.Thread(target=p,args=(p1))
threads.append(th1)
th2=threading.Thread(target=p,args=(p2))
threads.append(th2)

if __name__=='__main__':
for t in threads:
t.setDaemon(True)
t.start()




熱點內容
電腦加裝固態後需要怎麼配置 發布:2024-12-23 14:20:21 瀏覽:508
如何在伺服器上進行序列比對 發布:2024-12-23 14:15:25 瀏覽:284
ga6選哪個配置車 發布:2024-12-23 14:13:36 瀏覽:274
鴻蒙為什麼比安卓占內存 發布:2024-12-23 14:06:13 瀏覽:180
sql兩表更新 發布:2024-12-23 14:01:29 瀏覽:207
linux驅動spi 發布:2024-12-23 13:25:22 瀏覽:115
王思聰為什麼配伺服器 發布:2024-12-23 13:19:48 瀏覽:374
安卓型號代表什麼 發布:2024-12-23 13:13:29 瀏覽:780
改密碼哪裡加問題 發布:2024-12-23 13:11:43 瀏覽:865
安卓手機多開哪個不卡 發布:2024-12-23 13:10:16 瀏覽:589