python線程id

發布時間: 2023-11-26 18:13:31

1. python多進程和多線程的區別

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

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

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

線程的特點：

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

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

進程與線程區別：

同一個進程中的線程共享同一內存空間，但進程之間的內存空間是獨立的。
同一個進程中的所有線程的數據是共享的，但進程之間的數據是獨立的。
對主線程的修改可能會影響其他線程的行為，但是父進程的修改（除了刪除以外）不會影響其他子進程。
線程是一個上下文的執行指令，而進程則是與運算相關的一簇資源。
同一個進程的線程之間可以直接通信，但是進程之間的交流需要藉助中間代理來實現。
創建新的線程很容易，但是創建新的進程需要對父進程做一次復制。
一個線程可以操作同一進程的其他線程，但是進程只能操作其子進程。
線程啟動速度快，進程啟動速度慢（但是兩者運行速度沒有可比性）。

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

2. Python中threading的join和setDaemon的區別及用法

Python多線程編程時經常會用到join()和setDaemon()方法，基本用法如下：
join([time]): 等待至線程中止。這阻塞調用線程直至線程的join() 方法被調用中止-正常退出或者拋出未處理的異常-或者是可選的超時發生。
setDaemon，將該線程標記為守護線程或用戶線程

1、join ()方法：主線程A中，創建了子線程B，並且在主線程A中調用了B.join()，那麼，主線程A會在調用的地方等待，直到子線程B完成操作後，才可以接著往下執行，那麼在調用這個線程時可以使用被調用線程的join方法。
原型：join([timeout])，裡面的參數時可選的，代表線程運行的最大時間，即如果超過這個時間，不管這個此線程有沒有執行完畢都會被回收，然後主線程或函數都會接著執行的。

import threadingimport time class MyThread(threading.Thread): def __init__(self, id): threading.Thread.__init__(self) self.id = id def run(self): x = 0 time.sleep(10) print(self.id) print('線程結束：'+str(time.time())) if __name__ == "__main__": t1 = MyThread(999) print('線程開始：'+str(time.time())) t1.start() print('主線程列印開始：'+str(time.time())) for i in range(5): print(i) time.sleep(2) print('主線程列印結束：' + str(time.time()))

線程開始：1497534590.2784667
主線程列印開始：1497534590.2794669
0
1
2
3
4
主線程列印結束：1497534592.279581
999
線程結束：1497534600.2800388
從列印結果可知，線程t1 start後，主線程並沒有等線程t1運行結束後再執行，而是在線程執行的同時，執行了後面的語句。

現在，把join()方法加到啟動線程後面(其他代碼不變)

import threadingimport time class MyThread(threading.Thread): def __init__(self, id): threading.Thread.__init__(self) self.id = id def run(self): x = 0 time.sleep(10) print(self.id) print('線程結束：'+str(time.time())) if __name__ == "__main__": t1 = MyThread(999) print('線程開始：'+str(time.time())) t1.start() t1.join() print('主線程列印開始：'+str(time.time())) for i in range(5): print(i) time.sleep(2) print('主線程列印結束：' + str(time.time()))

線程開始：1497535176.5019968
999
線程結束：1497535186.5025687
主線程列印開始：1497535186.5025687
0
1
2
3
4
主線程列印結束：1497535188.5026832
線程t1 start後，主線程停在了join()方法處，等子線程t1結束後，主線程繼續執行join後面的語句。

2、setDaemon()方法。主線程A中，創建了子線程B，並且在主線程A中調用了B.setDaemon()，這個的意思是，把主線程A設置為守護線程，這時候，要是主線程A執行結束了，就不管子線程B是否完成，一並和主線程A退出.這就是setDaemon方法的含義，這基本和join是相反的。此外，還有個要特別注意的：必須在start() 方法調用之前設置。import threading
import time class MyThread(threading.Thread): def __init__(self, id): threading.Thread.__init__(self) self.id = id def run(self): x = 0 time.sleep(10) print(self.id) print("This is：" + self.getName()) # 獲取線程名稱 print('線程結束：' + str(time.time())) if __name__ == "__main__": t1 = MyThread(999) print('線程開始：'+str(time.time())) t1.setDaemon(True) t1.start() print('主線程列印開始：'+str(time.time())) for i in range(5): print(i) time.sleep(2) print('主線程列印結束：' + str(time.time()))

線程開始：1497536678.8509264
主線程列印開始：1497536678.8509264
0
1
2
3
4
主線程列印結束：1497536680.8510408

t1.setDaemon(True)的操作，將子線程設置為了守護線程。根據setDaemon()方法的含義，父線程列印內容後便結束了，不管子線程是否執行完畢了。
如果在線程啟動前沒有加t1.setDaemon(True)，輸出結果為：
線程開始：1497536865.3215919
主線程列印開始：1497536865.3215919
0
1
2
3
4
主線程列印結束：1497536867.3217063
999
This is：Thread-1
線程結束：1497536875.3221638
程序運行中，執行一個主線程，如果主線程又創建一個子線程，主線程和子線程就分兵兩路，分別運行，那麼當主線程完成想退出時，會檢驗子線程是否完成，如果子線程未完成，則主線程會等待子線程完成後再退出；
有時我們需要的是，子線程運行完，才繼續運行主線程，這時就可以用join方法（在線程啟動後面）；
但是有時候我們需要的是，只要主線程完成了，不管子線程是否完成，都要和主線程一起退出，這時就可以用setDaemon方法（在線程啟動前面）。

3. 小白都看懂了，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 核心數

4. 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 只能由本線程進行操作。

5. python之多線程

進程的概念：以一個整體的形式暴露給操作系統管理，裡麵包含各種資源的調用。對各種資源管理的集合就可以稱為進程。
線程的概念：是操作系統能夠進行運算調度的最小單位。本質上就是一串指令的集合。

進程和線程的區別：
1、線程共享內存空間，進程有獨立的內存空間。
2、線程啟動速度快，進程啟動速度慢。注意：二者的運行速度是無法比較的。
3、線程是執行的指令集，進程是資源的集合
4、兩個子進程之間數據不共享，完全獨立。同一個進程下的線程共享同一份數據。
5、創建新的線程很簡單，創建新的進程需要對他的父進程進行一次克隆。
6、一個線程可以操作（控制）同一進程里的其他線程，但是進程只能操作子進程
7、同一個進程的線程可以直接交流，兩個進程想要通信，必須通過一個中間代理來實現。
8、對於線程的修改，可能會影響到其他線程的行為。但是對於父進程的修改不會影響到子進程。

第一個程序，使用循環來創建線程，但是這個程序中一共有51個線程，我們創建了50個線程，但是還有一個程序本身的線程，是主線程。這51個線程是並行的。注意：這個程序中是主線程啟動了子線程。

相比上個程序，這個程序多了一步計算時間，但是我們觀察結果會發現，程序顯示的執行時間只有0.007秒，這是因為最後一個print函數它存在於主線程，而整個程序主線程和所有子線程是並行的，那麼可想而知，在子線程還沒有執行完畢的時候print函數就已經執行了，總的來說，這個時間只是執行了一個線程也就是主線程所用的時間。

接下來這個程序，吸取了上面這個程序的缺點，創建了一個列表，把所有的線程實例都存進去，然後使用一個for循環依次對線程實例調用join方法，這樣就可以使得主線程等待所創建的所有子線程執行完畢才能往下走。 注意實驗結果：和兩個線程的結果都是兩秒多一點

注意觀察實驗結果，並沒有執行列印task has done，並且程序執行時間極其短。
這是因為在主線程啟動子線程前把子線程設置為守護線程。
只要主線程執行完畢，不管子線程是否執行完畢，就結束。但是會等待非守護線程執行完畢
主線程退出，守護線程全部強制退出。皇帝死了，僕人也跟著殉葬
應用的場景： socket-server

注意：gil只是為了減低程序開發復雜度。但是在2.幾的版本上，需要加用戶態的鎖（gil的缺陷）而在3點幾的版本上，加鎖不加鎖都一樣。

下面這個程序是一個典型的生產者消費者模型。
生產者消費者模型是經典的在開發架構中使用的模型
運維中的集群就是生產者消費者模型，生活中很多都是

那麼，多線程的使用場景是什麼？
python中的多線程實質上是對上下文的不斷切換，可以說是假的多線程。而我們知道，io操作不佔用cpu，計算佔用cpu，那麼python的多線程適合io操作密集的任務，比如socket-server，那麼cpu密集型的任務，python怎麼處理？python可以折中的利用計算機的多核：啟動八個進程，每個進程有一個線程。這樣就可以利用多進程解決多核問題。

6. python里如何終止線程比如線程里調用os.system('adb logcat')這個是不會停止的

如果直接終止線程不清楚，要不曲線下，新開啟一個進程，再得到這個進程id，然後幹掉這個進程
import
multiprocessing
def
NewProcess():
global
id
id=os.getpid()
os.system('adb
logcat')
NP=multiporcess.Process(target=one
function,args=())
NP.start()
os.kill(id,9)

7. 一文帶你讀懂Python線程

Python線程

進程有很多優點，它提供了多道編程，可以提高計算機CPU的利用率。既然進程這么優秀，為什麼還要線程呢？其實，仔細觀察就會發現進程還是有很多缺陷的。

主要體現在一下幾個方面：

進程只能在一個時間做一個任務，如果想同時做兩個任務或多個任務，就必須開啟多個進程去完成多個任務。

進程在執行的過程中如果阻塞，例如等待輸入，整個進程就會掛起，即使進程中有些工作不依賴於輸入的數據，也將無法執行。

每個進程都有自己的獨立空間，所以多進程的創建，銷毀相比於多線程更加耗時，也更加佔用系統資源。

進程是資源分配的最小單位，線程是CPU調度的最小單位，每一個進程中至少有一個線程。

線程與進程的區別

可以歸納為以下4點：

1）地址空間：進程間相互獨立的每個進程都有自己獨立的內存空間，也就是說一個進程內的數據在另一個進程是不可見的。但同一進程中的各線程間數據是共享的。

2）通信：由於每個進程有自己獨立的內存空間，所以進程間通信需要IPC，而進程內的數據對於多個線程來說是共享的，每個線程都可以訪問，所以為了保證數據的一致性，需要使用鎖。

3）調度和切換：線程上下文切換比進程上下文切換要快得多。

4）在多線程操作系統中，進程不是一個可執行的實體，它主要的功能是向操作系統申請一塊內存空間，然後在內存空間中開線程來執行任務，相當於一個容器，容器中的線程才是真正的執行體。一個進程可以包含多個線程，而一個線程是不能包含進程的。因為進程是系統分配資源的最小單位，所以線程不能向操作系統申請自己的空間，但一個線程內可以包含多個線程。

python線程id

與python線程id相關的資訊