導航:首頁 > 編程語言 > python當前線程數

python當前線程數

發布時間:2022-11-29 03:37:55

python之多線程原理

並發:邏輯上具備同時處理多個任務的能力。
並行:物理上在同一時刻執行多個並發任務。

舉例:開個QQ,開了一個進程,開了微信,開了一個進程。在QQ這個進程裡面,傳輸文字開一個線程、傳輸語音開了一個線程、彈出對話框又開了一個線程。
總結:開一個軟體,相當於開了一個進程。在這個軟體運行的過程里,多個工作同時運轉,完成了QQ的運行,那麼這個多個工作分別有多個線程。

線程和進程之間的區別:

進程在python中的使用,對模塊threading進行操作,調用的這個三方庫。可以通過 help(threading) 了解其中的方法、變數使用情況。也可以使用 dir(threading) 查看目錄結構。

current_thread_num = threading.active_count() # 返回正在運行的線程數量
run_thread_len = len(threading.enumerate()) # 返回正在運行的線程數量
run_thread_list = threading.enumerate() # 返回當前運行線程的列表
t1=threading.Thread(target=dance) #創建兩個子線程,參數傳遞為函數名
t1.setDaemon(True) # 設置守護進程,守護進程:主線程結束時自動退出子線程。
t1.start() # 啟動子線程
t1.join() # 等待進程結束 exit()`# 主線程退出,t1子線程設置了守護進程,會自動退出。其他子線程會繼續執行。

② 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基礎(21)-線程通信

到這里,我們要聊一下線程通信的內容;
首先,我們拋開語言不談,先看看比較基礎的東西,線程間通信的方式;其實也就是哪幾種(我這里說的,是我的所謂的知道的。。。)事件,消息隊列,信號量,條件變數(鎖算不算?我只是認為是同步的一種);所以我們也就是要把這些掌握了,因為各有各的好處嘛;
條件變數我放到了上面的線程同步裡面講了,我總感覺這算是同步的一種,沒有很多具體信息的溝通;同時吧,我認為條件變數比較重要,因為這種可以應用於線程池的操作上;所以比較重要;這里,拋開條件變數不談,我們看看其他的東西;
1、消息隊列:
queue 模塊下提供了幾個阻塞隊列,這些隊列主要用於實現線程通信。在 queue 模塊下主要提供了三個類,分別代表三種隊列,它們的主要區別就在於進隊列、出隊列的不同。

關於這三個隊列類的簡單介紹如下:
queue.Queue(maxsize=0):代表 FIFO(先進先出)的常規隊列,maxsize 可以限制隊列的大小。如果隊列的大小達到隊列的上限,就會加鎖,再次加入元素時就會被阻塞,直到隊列中的元素被消費。如果將 maxsize 設置為 0 或負數,則該隊列的大小就是無限制的。
queue.LifoQueue(maxsize=0):代表 LIFO(後進先出)的隊列,與 Queue 的區別就是出隊列的順序不同。
PriorityQueue(maxsize=0):代表優先順序隊列,優先順序最小的元素先出隊列。

這三個隊列類的屬性和方法基本相同, 它們都提供了如下屬性和方法:
Queue.qsize():返回隊列的實際大小,也就是該隊列中包含幾個元素。
Queue.empty():判斷隊列是否為空。
Queue.full():判斷隊列是否已滿。
Queue.put(item, block=True, timeout=None):向隊列中放入元素。如果隊列己滿,且 block 參數為 True(阻塞),當前線程被阻塞,timeout 指定阻塞時間,如果將 timeout 設置為 None,則代表一直阻塞,直到該隊列的元素被消費;如果隊列己滿,且 block 參數為 False(不阻塞),則直接引發 queue.FULL 異常。
Queue.put_nowait(item):向隊列中放入元素,不阻塞。相當於在上一個方法中將 block 參數設置為 False。
Queue.get(item, block=True, timeout=None):從隊列中取出元素(消費元素)。如果隊列已滿,且 block 參數為 True(阻塞),當前線程被阻塞,timeout 指定阻塞時間,如果將 timeout 設置為 None,則代表一直阻塞,直到有元素被放入隊列中; 如果隊列己空,且 block 參數為 False(不阻塞),則直接引發 queue.EMPTY 異常。
Queue.get_nowait(item):從隊列中取出元素,不阻塞。相當於在上一個方法中將 block 參數設置為 False。
其實我們想想,這個隊列,是python進行封裝的,那麼我們可以用在線程間的通信;同時也是可以用做一個數據結構;先進先出就是隊列,後進先出就是棧;我們用這個棧寫個十進制轉二進制的例子:

沒毛病,可以正常的列印;其中需要注意的就是,maxsize在初始化的時候如果是0或者是個負數的話,那麼就會是不限制大小;
那麼其實我們想想,我們如果用做線程通信的話,我們兩個線程,可以把隊列設置為1的大小,如果是1對多,比如是創建者和消費者的關系,我們完全可以作為消息隊列,比如說創建者一直在創建一些東西,然後放入到消息隊列裡面,然後供消費著使用;就是一個很好的例子;所以,其實說是消息隊列,也就是隊列,沒差;
=====================================================================
下面來看一下事件
Event 是一種非常簡單的線程通信機制,一個線程發出一個 Event,另一個線程可通過該 Event 被觸發。

Event 本身管理一個內部旗標,程序可以通過 Event 的 set() 方法將該旗標設置為 True,也可以調用 clear() 方法將該旗標設置為 False。程序可以調用 wait() 方法來阻塞當前線程,直到 Event 的內部旗標被設置為 True。

Event 提供了如下方法:
is_set():該方法返回 Event 的內部旗標是否為True。
set():該方法將會把 Event 的內部旗標設置為 True,並喚醒所有處於等待狀態的線程。
clear():該方法將 Event 的內部旗標設置為 False,通常接下來會調用 wait() 方法來阻塞當前線程。
wait(timeout=None):該方法會阻塞當前線程。
這里我想解釋一下;其實對於事件來說,事件可以看成和條件變數是一樣的,只是我們說說不一樣的地方;
1、對於事件來說,一旦觸發了事件,也就是說,一旦set為true了,那麼就會一直為true,需要clear調內部的標志,才能繼續wait;但是conditon不是,他是一次性的喚醒其他線程;
2、conditon自己帶鎖;事件呢?不是的;沒有自己的鎖;比如說有一個存錢的線程,有一個是取錢的線程;那麼存錢的線程要存錢;需要怎麼辦呢?1、發現銀行沒有錢了(is_set判斷);2、鎖住銀行;3、存錢;4、釋放銀行;5、喚醒事件;對於取錢的人;1、判斷是否有錢;2、被喚醒了,然後鎖住銀行;3、開始取錢;4、清理告訴存錢的人,我沒錢了(clear);5、釋放鎖;6、等著錢存進去;
其實說白了,就是記住一點;這個旗標需要自己clear就對了
寫個例子,怕以後忘了怎麼用;

其實時間和信號量比較像;但是信號量不用自己清除標志位;但是事件是需要的;

④ python 如何控制多線程數量

import requests, timefrom threading import Threadclass MyThread(Thread):
def __init__(self, url):
Thread.__init__(self)
self.url = url def run(self):
open_url(self.url)def open_url(url):
r = requests.get(url[:-1])
print(r.status_code)
print(url) # return urlif __name__ == '__main__': with open("E:/all_domain.txt",'r') as f:
t_start = time.time()
threads = [] for url in f:
t = MyThread(url)
threads.append(t)
t.start()
print(len(threads)) for i in threads:
i.join()
t_end = time.time()
print('the thread way take %s s' % (t_end - t_start))

⑤ python3.5怎樣控制線程的數量

pool = threadpool.ThreadPool(poolSize)
poolSize這里來控制線程數量

import threadpool
import requests

def get_url(url):
r = requests.get(url)
return url, r.status_code

def print_result(request, result):
print result

urls = [

]

pool = threadpool.ThreadPool(5)

for th in threadpool.makeRequests(get_url, urls, print_result):
pool.putRequest(th)

pool.wait()

⑥ python 查看進程 多少線程

threading模塊有active_count()方法,它是獲取當前激活的線程數量。用法很簡單
import threading
threading.active_count()

⑦ 小白都看懂了,Python 中的線程和進程精講,建議收藏

目錄

眾所周知,CPU是計算機的核心,它承擔了所有的計算任務。而操作系統是計算機的管理者,是一個大管家,它負責任務的調度,資源的分配和管理,統領整個計算機硬體。應用程序是具有某種功能的程序,程序運行與操作系統之上

在很早的時候計算機並沒有線程這個概念,但是隨著時代的發展,只用進程來處理程序出現很多的不足。如當一個進程堵塞時,整個程序會停止在堵塞處,並且如果頻繁的切換進程,會浪費系統資源。所以線程出現了

線程是能擁有資源和獨立運行的最小單位,也是程序執行的最小單位。一個進程可以擁有多個線程,而且屬於同一個進程的多個線程間會共享該進行的資源

① 200 多本 Python 電子書(和經典的書籍)應該有

② Python標准庫資料(最全中文版)

③ 項目源碼(四五十個有趣且可靠的練手項目及源碼)

④ Python基礎入門、爬蟲、網路開發、大數據分析方面的視頻(適合小白學習)

⑤ Python學習路線圖(告別不入流的學習)
私信我01即可獲取大量Python學習資源

進程時一個具有一定功能的程序在一個數據集上的一次動態執行過程。進程由程序,數據集合和進程式控制制塊三部分組成。程序用於描述進程要完成的功能,是控制進程執行的指令集;數據集合是程序在執行時需要的數據和工作區;程序控制塊(PCB)包含程序的描述信息和控制信息,是進程存在的唯一標志

在Python中,通過兩個標准庫 thread 和 Threading 提供對線程的支持, threading 對 thread 進行了封裝。 threading 模塊中提供了 Thread , Lock , RLOCK , Condition 等組件

在Python中線程和進程的使用就是通過 Thread 這個類。這個類在我們的 thread 和 threading 模塊中。我們一般通過 threading 導入

默認情況下,只要在解釋器中,如果沒有報錯,則說明線程可用

守護模式:

現在我們程序代碼中,有多個線程, 並且在這個幾個線程中都會去 操作同一部分內容,那麼如何實現這些數據的共享呢?

這時,可以使用 threading庫裡面的鎖對象 Lock 去保護

Lock 對象的acquire方法 是申請鎖

每個線程在操作共享數據對象之前,都應該申請獲取操作權,也就是調用該共享數據對象對應的鎖對象的acquire方法,如果線程A 執行了 acquire() 方法,別的線程B 已經申請到了這個鎖, 並且還沒有釋放,那麼 線程A的代碼就在此處 等待 線程B 釋放鎖,不去執行後面的代碼。

直到線程B 執行了鎖的 release 方法釋放了這個鎖, 線程A 才可以獲取這個鎖,就可以執行下面的代碼了

如:

到在使用多線程時,如果數據出現和自己預期不符的問題,就可以考慮是否是共享的數據被調用覆蓋的問題

使用 threading 庫裡面的鎖對象 Lock 去保護

Python中的多進程是通過multiprocessing包來實現的,和多線程的threading.Thread差不多,它可以利用multiprocessing.Process對象來創建一個進程對象。這個進程對象的方法和線程對象的方法差不多也有start(), run(), join()等方法,其中有一個方法不同Thread線程對象中的守護線程方法是setDeamon,而Process進程對象的守護進程是通過設置daemon屬性來完成的

守護模式:

其使用方法和線程的那個 Lock 使用方法類似

Manager的作用是提供多進程共享的全局變數,Manager()方法會返回一個對象,該對象控制著一個服務進程,該進程中保存的對象運行其他進程使用代理進行操作

語法:

線程池的基類是 concurrent.futures 模塊中的 Executor , Executor 提供了兩個子類,即 ThreadPoolExecutor 和 ProcessPoolExecutor ,其中 ThreadPoolExecutor 用於創建線程池,而 ProcessPoolExecutor 用於創建進程池

如果使用線程池/進程池來管理並發編程,那麼只要將相應的 task 函數提交給線程池/進程池,剩下的事情就由線程池/進程池來搞定

Exectuor 提供了如下常用方法:

程序將 task 函數提交(submit)給線程池後,submit 方法會返回一個 Future 對象,Future 類主要用於獲取線程任務函數的返回值。由於線程任務會在新線程中以非同步方式執行,因此,線程執行的函數相當於一個「將來完成」的任務,所以 Python 使用 Future 來代表

Future 提供了如下方法:

使用線程池來執行線程任務的步驟如下:

最佳線程數目 = ((線程等待時間+線程CPU時間)/線程CPU時間 )* CPU數目

也可以低於 CPU 核心數

使用線程池來執行線程任務的步驟如下:

關於進程的開啟代碼一定要放在 if __name__ == '__main__': 代碼之下,不能放到函數中或其他地方

開啟進程的技巧

開啟進程的數量最好低於最大 CPU 核心數

⑧ python 如何設置threading.thread線程數量

#encoding:utf8 import threading import time data = 0 def func(sleeptime): global data print threading.currentThread().getName() time.sleep(sleeptime) threads = [] for i in range(0,40): t = threading.Thread(target=func,args=(i,)) threads.append(t) num = 0 for t in threads: t.start() while True: #判斷正在運行的線程數量,如果小於5則退出while循環, #進入for循環啟動新的進程.否則就一直在while循環進入死循環 if(len(threading.enumerate()) < 5): break

⑨ python最大支持多少線程

那啥,python線程太慢了,想並發去用greenlet吧,快,寫起來還方便。
如果加鎖同步的話,線程多了反而變慢也有可能。
ulimit -s 返回線程棧大小,我的默認是8192, 用內存大小除以它就得到理論上的線程數吧。

⑩ python 線程池的使用

最近在做一個爬蟲相關的項目,單線程的整站爬蟲,耗時真的不是一般的巨大,運行一次也是心累,,,所以,要想實現整站爬蟲,多線程是不可避免的,那麼python多線程又應該怎樣實現呢?這里主要要幾個問題(關於python多線程的GIL問題就不再說了,網上太多了)。

一、 既然多線程可以縮短程序運行時間,那麼,是不是線程數量越多越好呢?

顯然,並不是,每一個線程的從生成到消亡也是需要時間和資源的,太多的線程會佔用過多的系統資源(內存開銷,cpu開銷),而且生成太多的線程時間也是可觀的,很可能會得不償失,這里給出一個最佳線程數量的計算方式:

最佳線程數的獲取:

1、通過用戶慢慢遞增來進行性能壓測,觀察QPS(即每秒的響應請求數,也即是最大吞吐能力。),響應時間

2、根據公式計算:伺服器端最佳線程數量=((線程等待時間+線程cpu時間)/線程cpu時間) * cpu數量

3、單用戶壓測,查看CPU的消耗,然後直接乘以百分比,再進行壓測,一般這個值的附近應該就是最佳線程數量。

二、為什麼要使用線程池?

對於任務數量不斷增加的程序,每有一個任務就生成一個線程,最終會導致線程數量的失控,例如,整站爬蟲,假設初始只有一個鏈接a,那麼,這個時候只啟動一個線程,運行之後,得到這個鏈接對應頁面上的b,c,d,,,等等新的鏈接,作為新任務,這個時候,就要為這些新的鏈接生成新的線程,線程數量暴漲。在之後的運行中,線程數量還會不停的增加,完全無法控制。所以,對於任務數量不端增加的程序,固定線程數量的線程池是必要的。

三、如何使用線程池
過去使用threadpool模塊,現在一般使用concurrent.futures模塊,這個模塊是python3中自帶的模塊,但是,python2.7以上版本也可以安裝使用,具體使用方式如下:

注意到:
concurrent.futures.ThreadPoolExecutor,在提交任務的時候,有兩種方式,一種是submit()函數,另一種是map()函數,兩者的主要區別在於:

閱讀全文

與python當前線程數相關的資料

熱點內容
壓縮包多長時間能解壓 瀏覽:370
小說男主叫江宴女主叫溫暖 瀏覽:455
有一部小說主角叫唐糖 瀏覽:302
找一部小說主角叫陸宇 瀏覽:402
受重生悔過的小說 瀏覽:959
單片機顯示模塊電路 瀏覽:305
交換老婆系列小說 瀏覽:280
支持投屏的在線影院 瀏覽:844
男主是鴨子公關 瀏覽:61
yy680 瀏覽:787
二戰德國納粹電影 瀏覽:504
雲存儲搭建伺服器 瀏覽:851
被禁的40部小說有哪些 瀏覽:247
通吃小子好小子小傑 瀏覽:46
肉多的霸總文 瀏覽:943
可以投屏的電影網站 瀏覽:402
黃有聲故事 瀏覽:486
重生末世之塵華 瀏覽:748
優化演算法的輸入維數越不容易收斂 瀏覽:779
java極限編程pdf 瀏覽:132