python進程創建線程

發布時間: 2022-05-26 08:32:19

㈠ 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什麼情況創建多線程，什麼情況創建多進程

計算密集型，創建多進程；IO密集型，創建多線程。

㈢ python3 創建線程時不用args傳參，執行線程時為什麼不是同時執行

在Python多線程下，每個線程的執行方式：
1、獲取GIL
2、執行代碼直到sleep或者是python虛擬機將其掛起。
3、釋放GIL

可見，某個線程想要執行，必須先拿到GIL，我們可以把GIL看作是「通行證」，並且在一個python進程中，GIL只有一個。拿不到通行證的線程，就不允許進入CPU執行。

在Python2.x里，GIL的釋放邏輯是當前線程遇見IO操作或者ticks計數達到100（ticks可以看作是Python自身的一個計數器，專門做用於GIL，每次釋放後歸零，這個計數可以通過
sys.setcheckinterval 來調整），進行釋放。

而每次釋放GIL鎖，線程進行鎖競爭、切換線程，會消耗資源。並且由於GIL鎖存在，python里一個進程永遠只能同時執行一個線程(拿到GIL的線程才能執行)，這就是為什麼在多核CPU上，python的多線程效率並不高。

那麼是不是python的多線程就完全沒用了呢？
在這里我們進行分類討論：
1、CPU密集型代碼(各種循環處理、計數等等)，在這種情況下，由於計算工作多，ticks計數很快就會達到閾值，然後觸發GIL的釋放與再競爭（多個線程來回切換當然是需要消耗資源的），所以python下的多線程對CPU密集型代碼並不友好。

2、IO密集型代碼(文件處理、網路爬蟲等)，多線程能夠有效提升效率(單線程下有IO操作會進行IO等待，造成不必要的時間浪費，而開啟多線程能在線程A等待時，自動切換到線程B，可以不浪費CPU的資源，從而能提升程序執行效率)。所以python的多線程對IO密集型代碼比較友好。

而在python3.x中，GIL不使用ticks計數，改為使用計時器（執行時間達到閾值後，當前線程釋放GIL），這樣對CPU密集型程序更加友好，但依然沒有解決GIL導致的同一時間只能執行一個線程的問題，所以效率依然不盡如人意。

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

回到最開始的問題：經常我們會聽到老手說：「python下想要充分利用多核CPU，就用多進程」，原因是什麼呢？

原因是：每個進程有各自獨立的GIL，互不幹擾，這樣就可以真正意義上的並行執行，所以在python中，多進程的執行效率優於多線程(僅僅針對多核CPU而言)。

所以在這里說結論：多核下，想做並行提升效率，比較通用的方法是使用多進程，能夠有效提高執行效率

㈣書聲琅琅教育旗下智圭谷：如何在Python中實現多線程

python主要是通過thread和threading這兩個模塊來實現多線程支持。
python的thread模塊是比較底層的模塊，python的threading模塊是對thread做了一些封裝，可以更加方便的被使用。但是python（cpython）由於GIL的存在無法使用threading充分利用CPU資源，如果想充分發揮多核CPU的計算能力需要使用multiprocessing模塊(Windows下使用會有諸多問題)。
python3.x中已經摒棄了Python2.x中採用函數式thread模塊中的start_new_thread()函數來產生新線程方式。python3.x中通過threading模塊創建新的線程有兩種方法：
1、通過threading.Thread(Target=executable Method)-即傳遞給Thread對象一個可執行方法（或對象）
2、繼承threading.Thread定義子類並重寫run()方法。第二種方法中，唯一必須重寫的方法是run()。
了解更多python知識,0基礎新手python在線學習就上智圭谷-書聲琅琅教育旗下高端IT教育品牌,專注python語言領域

㈤ Python多線程是什麼意思

簡單地說就是作為可能是僅有的支持多線程的解釋型語言（perl的多線程是殘疾，PHP沒有多線程），Python的多線程是有compromise的，在任意時間只有一個Python解釋器在解釋Python bytecode。
UPDATE：如評論指出，Ruby也是有thread支持的，而且至少Ruby MRI是有GIL的。
如果你的代碼是CPU密集型，多個線程的代碼很有可能是線性執行的。所以這種情況下多線程是雞肋，效率可能還不如單線程因為有context switch
但是：如果你的代碼是IO密集型，多線程可以明顯提高效率。例如製作爬蟲（我就不明白為什麼Python總和爬蟲聯系在一起…不過也只想起來這個例子…），絕大多數時間爬蟲是在等待socket返回數據。這個時候C代碼里是有release GIL的，最終結果是某個線程等待IO的時候其他線程可以繼續執行。
反過來講：你就不應該用Python寫CPU密集型的代碼…效率擺在那裡…
如果確實需要在CPU密集型的代碼里用concurrent，就去用multiprocessing庫。這個庫是基於multi process實現了類multi thread的API介面，並且用pickle部分地實現了變數共享。
再加一條，如果你不知道你的代碼到底算CPU密集型還是IO密集型，教你個方法：
multiprocessing這個mole有一個mmy的sub mole，它是基於multithread實現了multiprocessing的API。
假設你使用的是multiprocessing的Pool，是使用多進程實現了concurrency
from multiprocessing import Pool
如果把這個代碼改成下面這樣，就變成多線程實現concurrency
from multiprocessing.mmy import Pool
兩種方式都跑一下，哪個速度快用哪個就行了。
UPDATE:
剛剛才發現concurrent.futures這個東西，包含ThreadPoolExecutor和ProcessPoolExecutor，可能比multiprocessing更簡單

㈥ Python中進程與線程的區別是什麼

Num01–>線程

線程是操作系統中能夠進行運算調度的最小單位。它被包含在進程之中，是進程中的實際運作單位。

一個線程指的是進程中一個單一順序的控制流。

一個進程中可以並發多條線程，每條線程並行執行不同的任務。

Num02–>進程

進程就是一個程序在一個數據集上的一次動態執行過程。

進程有以下三部分組成：

1，程序：我們編寫的程序用來描述進程要完成哪些功能以及如何完成。
2，數據集：數據集則是程序在執行過程中需要的資源，比如圖片、音視頻、文件等。
3，進程式控制制塊：進程式控制制塊是用來記錄進程的外部特徵，描述進程的執行變化過程，系統可以用它來控制和管理進程，它是系統感知進程存在的唯一標記。

Num03–>進程和線程的區別：

1、運行方式不同：

進程不能單獨執行，它只是資源的集合。

進程要操作CPU，必須要先創建一個線程。

所有在同一個進程里的線程，是同享同一塊進程所佔的內存空間。

2，關系

進程中第一個線程是主線程，主線程可以創建其他線程；其他線程也可以創建線程；線程之間是平等的。

進程有父進程和子進程，獨立的內存空間，唯一的標識符：pid。

3，速度

啟動線程比啟動進程快。

運行線程和運行進程速度上是一樣的，沒有可比性。

線程共享內存空間，進程的內存是獨立的。

4，創建

父進程生成子進程，相當於復制一份內存空間，進程之間不能直接訪問

創建新線程很簡單，創建新進程需要對父進程進行一次復制。

一個線程可以控制和操作同級線程里的其他線程，但是進程只能操作子進程。

5，交互

同一個進程里的線程之間可以直接訪問。

兩個進程想通信必須通過一個中間代理來實現。

python進程創建線程

與python進程創建線程相關的資訊