python多進程與多線程

發布時間: 2022-11-17 08:22:57

① 為什麼在python里推薦使用多進程而不是多線程

在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的多線程中存在PIL鎖，因此python的多線程不能利用多核，那麼，由於現在的計算機是多核的，就不能充分利用計算機的多核資源。但是python中的多進程是可以跑在不同的cpu上的。因此，嘗試了多進程+多線程的方式，來做一個任務。比如：從中科大的鏡像源中下載多個rpm包。
#!/usr/bin/pythonimport reimport commandsimport timeimport multiprocessingimport threadingdef download_image(url):
print '*****the %s rpm begin to download *******' % url
commands.getoutput('wget %s' % url)def get_rpm_url_list(url):
commands.getoutput('wget %s' % url)
rpm_info_str = open('index.html').read()

regu_mate = '(?<=<a href=")(.*?)(?=">)'
rpm_list = re.findall(regu_mate, rpm_info_str)

rpm_url_list = [url + rpm_name for rpm_name in rpm_list] print 'the count of rpm list is: ', len(rpm_url_list) return rpm_url_
def multi_thread(rpm_url_list):
threads = [] # url = 'https://mirrors.ustc.e.cn/centos/7/os/x86_64/Packages/'
# rpm_url_list = get_rpm_url_list(url)
for index in range(len(rpm_url_list)): print 'rpm_url is:', rpm_url_list[index]
one_thread = threading.Thread(target=download_image, args=(rpm_url_list[index],))
threads.append(one_thread)

thread_num = 5 # set threading pool, you have put 4 threads in it
while 1:
count = min(thread_num, len(threads)) print '**********count*********', count ###25,25,...6707%25

res = [] for index in range(count):
x = threads.pop()
res.append(x) for thread_index in res:
thread_index.start() for j in res:
j.join() if not threads:
def multi_process(rpm_url_list):
# process num at the same time is 4
process = []
rpm_url_group_0 = []
rpm_url_group_1 = []
rpm_url_group_2 = []
rpm_url_group_3 = [] for index in range(len(rpm_url_list)): if index % 4 == 0:
rpm_url_group_0.append(rpm_url_list[index]) elif index % 4 == 1:
rpm_url_group_1.append(rpm_url_list[index]) elif index % 4 == 2:
rpm_url_group_2.append(rpm_url_list[index]) elif index % 4 == 3:
rpm_url_group_3.append(rpm_url_list[index])
rpm_url_groups = [rpm_url_group_0, rpm_url_group_1, rpm_url_group_2, rpm_url_group_3] for each_rpm_group in rpm_url_groups:
each_process = multiprocessing.Process(target = multi_thread, args = (each_rpm_group,))
process.append(each_process) for one_process in process:
one_process.start() for one_process in process:
one_process.join()# for each_url in rpm_url_list:# print '*****the %s rpm begin to download *******' %each_url## commands.getoutput('wget %s' %each_url)
def main():
url = 'https://mirrors.ustc.e.cn/centos/7/os/x86_64/Packages/'
url_paas = 'http://mirrors.ustc.e.cn/centos/7.3.1611/paas/x86_64/openshift-origin/'
url_paas2 ='http://mirrors.ustc.e.cn/fedora/development/26/Server/x86_64/os/Packages/u/'

start_time = time.time()
rpm_list = get_rpm_url_list(url_paas) print multi_process(rpm_list) # print multi_thread(rpm_list)
#print multi_process()
# print multi_thread(rpm_list)
# for index in range(len(rpm_list)):
# print 'rpm_url is:', rpm_list[index]
end_time = time.time() print 'the download time is:', end_time - start_timeprint main()123456789101112131415161718

代碼的功能主要是這樣的：
main（）方法中調用get_rpm_url_list（base_url）方法，獲取要下載的每個rpm包的具體的url地址。其中base_url即中科大基礎的鏡像源的地址，比如：http://mirrors.ustc.e.cn/centos/7.3.1611/paas/x86_64/openshift-origin/，這個地址下有幾十個rpm包，get_rpm_url_list方法將每個rpm包的url地址拼出來並返回。
multi_process（rpm_url_list）啟動多進程方法，在該方法中，會調用多線程方法。該方法啟動4個多進程，將上面方法得到的rpm包的url地址進行分組，分成4組，然後每一個組中的rpm包再最後由不同的線程去執行。從而達到了多進程+多線程的配合使用。
代碼還有需要改進的地方，比如多進程啟動的進程個數和rpm包的url地址分組是硬編碼，這個還需要改進，畢竟，不同的機器，適合同時啟動的進程個數是不同的。

③ Python高階（一） - 單線程、多線程和多進程的效率對比測試

多線程的目的 - 「最大限度地利用CPU資源」。每個程序執行時都會產生一個進程，而每一個進程至少要有一個主線程。對於單CPU來說（沒有開啟超線程），在同一時間只能執行一個線程，所以如果想實現多任務，那麼就只能每個進程或線程獲得一個時間片，在某個時間片內，只能一個線程執行，然後按照某種策略換其他線程執行。由於時間片很短，這樣給用戶的感覺是同時有好多線程在執行。
Python是運行在解釋器中的語言，查找資料知道，python中有一個全局鎖（GIL），在使用多線程(Thread)的情況下，不能發揮多核的優勢。而使用多進程(Multiprocess)，則可以發揮多核的優勢真正地提高效率。

單線程、多線程和多進程的效率對比測試： github地址

資料顯示，如果多線程的進程是CPU密集型的，那多線程並不能有多少效率上的提升，相反還可能會因為線程的頻繁切換，導致效率下降，推薦使用多進程；如果是IO密集型，多線程進程可以利用IO阻塞等待時的空閑時間執行其他線程，提升效率。所以我們根據實驗對比不同場景的效率

| CPU密集型操作| IO密集型操作| 網路請求密集型操作
-- | -- | --| --
線性操作| 69.73533328374 |17.76633326213 | 6.78833333651
多線程操作| 75.40299995740 |145.68366670609 | 1.93999997775
多進程操作| 13.97433336576 | 4.67833328247| 2.38333328565

僅個人觀點，，歡迎留言~~~

④ python中多進程和多線程的區別

什麼是線程、進程?
進程(process)與線程(thread)是操作系統的基本概念，它們比較抽象，不容易掌握。
關於這兩者，最經典的一句話就是「進程是資源分配的最小單位，線程是CPU調度的最小單位」，線程是程序中一個單一的順序控制流程，進程內一個相對獨立的、可調度的執行單元，是系統獨立調度和分配CPU的基本單位指運行中的程序的調度單位，在單個程序中同時運行多個線程完成不同的工作，稱為多線程。
進程與線程的區別是什麼?
進程是資源分配的基本單位，所有與該進程有關的資源，都被記錄在進程式控制制塊PCB中，以表示該進程擁有這些資源或正在使用它們，另外，進程也是搶占處理機的調度單位，它擁有一個完整的虛擬地址空間，當進程發生調度時，不同的進程擁有不同的虛擬地址空間，而同一進程內的不同線程共享同一地址空間。
與進程相對應的，線程與資源分配無關，它屬於某一個進程，並與進程內的其他線程一起共享進程的資源，線程只由相關堆棧(系統棧或用戶棧)寄存器和線程式控制製表TCB組成，寄存器可被用來存儲線程內的局部變數，但不能存儲其他線程的相關變數。
通常在一個進程中可以包含若干個線程，它們可以利用進程所擁有的資源，在引入線程的操作系統中，通常都是把進程作為分配資源的基本單位，而把線程作為獨立運行和獨立調度的基本單位。
由於線程比進程更小，基本上不擁有系統資源，所以對它的調度所付出的開銷就會小得多，能更高效的提高系統內多個程序間並發執行的程度，從而顯著提高系統資源的利用率和吞吐量。
因而近年來推出的通用操作系統都引入了線程，以便進一步提高系統的並發性，並把它視為現代操作系統的一個重要指標。

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

GIL在Python中,由於歷史原因(GIL),使得Python中多線程的效果非常不理想.GIL使得任何時刻Python只能利用一個CPU核,並且它的調度演算法簡單粗暴:多線程中,讓每個線程運行一段時間t,然後強行掛起該線程,繼而去運行其他線程,如此周而復始,直到所有線程結束.這使得無法有效利用計算機系統中的"局部性",頻繁的線程切換也對緩存不是很友好,造成資源的浪費.據說Python官方曾經實現了一個去除GIL的Python解釋器,但是其效果還不如有GIL的解釋器,遂放棄.後來Python官方推出了"利用多進程替代多線程"的方案,在Python3中也有concurrent.futures這樣的包,讓我們的程序編寫可以做到"簡單和性能兼得".多進程/多線程+Queue一般來說,在Python中編寫並發程序的經驗是:計算密集型任務使用多進程,IO密集型任務使用多進程或者多線程.另外,因為涉及到資源共享,所以需要同步鎖等一系列麻煩的步驟,代碼編寫不直觀.另外一種好的思路是利用多進程/多線程+Queue的方法,可以避免加鎖這樣麻煩低效的方式.現在在Python2中利用Queue+多進程的方法來處理一個IO密集型任務.假設現在需要下載多個網頁內容並進行解析,單進程的方式效率很低,所以使用多進程/多線程勢在必行.我們可以先初始化一個tasks隊列,裡面將要存儲的是一系列dest_url,同時開啟4個進程向tasks中取任務然後執行,處理結果存儲在一個results隊列中,最後對results中的結果進行解析.最後關閉兩個隊列.下面是一些主要的邏輯代碼.#-*-coding:utf-8-*-#IO密集型任務#多個進程同時下載多個網頁#利用Queue+多進程#由於是IO密集型,所以同樣可以利用threading模塊importmultiprocessingdefmain():tasks=multiprocessing.JoinableQueue()results=multiprocessing.Queue()cpu_count=multiprocessing.cpu_count()#進程數目==CPU核數目create_process(tasks,results,cpu_count)#主進程馬上創建一系列進程,但是由於阻塞隊列tasks開始為空,副進程全部被阻塞add_tasks(tasks)#開始往tasks中添加任務parse(tasks,results)#最後主進程等待其他線程處理完成結果defcreate_process(tasks,results,cpu_count):for_inrange(cpu_count):p=multiprocessing.Process(target=_worker,args=(tasks,results))#根據_worker創建對應的進程p.daemon=True#讓所有進程可以隨主進程結束而結束p.start()#啟動def_worker(tasks,results):whileTrue:#因為前面所有線程都設置了daemon=True,故不會無限循環try:task=tasks.get()#如果tasks中沒有任務,則阻塞result=_download(task)results.put(result)#:tasks.task_done()defadd_tasks(tasks):forurlinget_urls():#get_urls()returnaurls_listtasks.put(url)defparse(tasks,results):try:tasks.join()exceptKeyboardInterruptaserr:print"Taskshasbeenstopped!"printerrwhilenotresults.empty():_parse(results)if__name__=='__main__':main()利用Python3中的concurrent.futures包在Python3中可以利用concurrent.futures包,編寫更加簡單易用的多線程/多進程代碼.其使用感覺和java的concurrent框架很相似(借鑒?)比如下面的簡單代碼示例defhandler():futures=set()withconcurrent.futures.ProcessPoolExecutor(max_workers=cpu_count)asexecutor:fortaskinget_task(tasks):future=executor.submit(task)futures.add(future)defwait_for(futures):try:forfutureinconcurrent.futures.as_completed(futures):err=futures.exception()ifnoterr:result=future.result()else::forfutureinfutures:future.cancel()print"Taskhasbeencanceled!"printereturnresult總結要是一些大型Python項目也這般編寫,那麼效率也太低了.在Python中有許多已有的框架使用,使用它們起來更加高效.

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

Num01–>線程

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

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

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

Num02–>進程

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

進程有以下三部分組成：

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

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

1、運行方式不同：

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

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

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

2，關系

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

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

3，速度

啟動線程比啟動進程快。

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

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

4，創建

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

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

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

5，交互

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

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

相關推薦：

Python中的進程是什麼

⑦ 多線程 python和多進程的區別

前面的章節，我們剛剛介紹過socket和socketserver網路編程。

在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里推薦使用多進程而不是多線程

首先強調背景：

1. GIL是什麼？

GIL的全稱是Global Interpreter Lock(全局解釋器鎖)，來源是python設計之初的考慮，為了數據安全所做的決定。

2. 每個CPU在同一時間只能執行一個線程

在單核CPU下的多線程其實都只是並發，不是並行，並發和並行從宏觀上來講都是同時處理多路請求的概念。但並發和並行又有區別，並行是指兩個或者多個事件在同一時刻發生；而並發是指兩個或多個事件在同一時間間隔內發生。

在Python多線程下，每個線程的執行方式：

獲取GIL
執行代碼直到sleep或者是python虛擬機將其掛起。
釋放GIL

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

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

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

那麼是不是python的多線程就完全沒用了呢？

在這里我們進行分類討論：

CPU密集型代碼(各種循環處理、計數等等)，在這種情況下，由於計算工作多，ticks計數很快就會達到閾值，然後觸發GIL的釋放與再競爭（多個線程來回切換當然是需要消耗資源的），所以python下的多線程對CPU密集型代碼並不友好。
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 中沒有真正的並行，只有並發
無論你的機器有多少個CPU, 同一時間只有一個Python解析器執行。這也和大部分解釋型語言一致，都不支持並行。這應該是python設計的先天缺陷。
javascript也是相同的道理， javascript早起的版本只支持單任務，後來通過worker來支持並發。
Python中的多線程
先復習一下進程和線程的概念
所謂進程，簡單的說就是一段程序的動態執行過程，是系統進行資源分配和調度的一個基本單位。一個進程中又可以包含若干個獨立的執行流，我們將這些執行流稱為線程，線程是CPU調度和分配的基本單位。同一個進程的線程都有自己的專有寄存器，但內存等資源是共享的。
這里有一個更加形象的解釋，出自阮一峰大神的傑作：
http://www.ruanyifeng.com/blog/2013/04/processes_and_threads.html
Python中的thread的使用
通過 thread.start_new_thread 方法
import thread
import time

# Define a function for the thread
def print_time( threadName, delay):
count = 0
while count < 5:
time.sleep(delay)
count += 1
print "%s: %s" % ( threadName, time.ctime(time.time()) )

# Create two threads as follows
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
#!/usr/bin/python
import threading
import time
exitFlag = 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 "Starting " + self.name
print_time(self.name, self.counter, 5)
print "Exiting " + self.name

def print_time(threadName, delay, counter):
while counter:
if exitFlag:
threadName.exit()
time.sleep(delay)
print "%s: %s" % (threadName, time.ctime(time.time()))
counter -= 1

# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# Start new Threads
thread1.start()
thread2.start()
print "Exiting Main Thread"

線程的同步
#!/usr/bin/python

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
# Get lock to synchronize threads
threadLock.acquire()
print_time(self.name, self.counter, 3)
# Free lock to release next thread
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 = []

# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# Start new Threads
thread1.start()
thread2.start()

# Add threads to thread list
threads.append(thread1)
threads.append(thread2)

# Wait for all threads to complete
for t in threads:
t.join()
print "Exiting Main Thread"

利用multiprocessing多進程實現並行
進程的創建
Python 中有一套類似多線程API 的的類來進行多進程開發: multiprocessing
這里是一個來自官方文檔的例子：
from multiprocessing import Process
def f(name):
print 'hello', name

if __name__ == '__main__':
p = Process(target=f, args=('bob',))
p.start()
p.join()

類似與線程，一可以通過繼承process類來實現：
from multiprocessing import Process
class Worker(Process):
def run(self):
print("in" + self.name)

if __name__ == '__main__':
jobs = []
for i in range(5):
p = Worker()
jobs.append(p)
p.start()
for j in jobs:
j.join()

進程的通信
Pipe()
pipe()函數返回一對由雙向通信的管道連接的對象，這兩個對象通過send, recv 方法實現信息的傳遞
from multiprocessing import Process, Pipe

def f(conn):
conn.send([42, None, 'hello'])
conn.close()

if __name__ == '__main__':
parent_conn, child_conn = Pipe()
p = Process(target=f, args=(child_conn,))
p.start()
print parent_conn.recv() # prints "[42, None, 'hello']"
p.join()

Quene
from multiprocessing import Process, Queue
def f(q):
q.put([42, None, 'hello'])

if __name__ == '__main__':
q = Queue()
p = Process(target=f, args=(q,))
p.start()
print q.get() # prints "[42, None, 'hello']"
p.join()

進程間的同步
Python 中多進程中也有類似線程鎖的概念，使用方式幾乎一樣：
from multiprocessing import Process, Lock
def f(l, i):
l.acquire()
print 'hello world', i
l.release()
if __name__ == '__main__':
lock = Lock()
for num in range(10):
Process(target=f, args=(lock, num)).start()

進程間的共享內存
每個進程都有獨自的內存，是不能相互訪問的，也行 python官方覺得通過進程通信的方式過於麻煩，提出了共享內存的概念，以下是官方給出的例子：
from multiprocessing import Process, Value, Array

def f(n, a):
n.value = 3.1415927
for i in range(len(a)):
a[i] = -a[i]

if __name__ == '__main__':
num = Value('d', 0.0)
arr = Array('i', range(10))

p = Process(target=f, args=(num, arr))
p.start()
p.join()

print num.value
print arr[:]

總結
python通過多進程實現多並行，充分利用多處理器，彌補了語言層面不支持多並行的缺點。Python, Node.js等解釋型語言似乎都是通過這種方式來解決同一個時間，一個解釋器只能處理一段程序的問題，十分巧妙。

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

首先你要搞清楚進程和線程的關系：線程是最小的執行單元，而進程由至少一個線程組成。

multiprocessing模塊是一個跨平台版本的多進程模塊。該模塊提供了process類來代表一個進程對象。

Process

構造方法__init__(self, group=None, target=None, name=None, args=(), kwargs={})

參數說明：

group：進程所屬組。基本不用

target：表示調用對象或方法名稱。

args：表示調用對象的位置參數元組。

name：別名

kwargs：表示調用對象的字典。

示例代碼如下：

threading本身就可以創建多個線程：

hreads = []#定義一個線程池

t1 = threading.Thread(target=one,args=(,))#建立一個線程並且賦給t1，這個線程指定調用方法one，並且不帶參數

threads.append(t1)#把t1線程裝到threads線程池裡

t2 = threading.Thread(target=two)

threads.append(t2)

t3 = threading.Thread(target=three)

threads.append(t3)

這時threads這個列表中就有三個線程裝在裡面了。

下面就是運行這個線程池裡面的線程

for t in threads:

用一個for語句遍歷threads里的線程，然後調用start()方法運行

注意t.join()必須放在for語句外面。

閱讀全文

熱點內容

谷能壓縮機發布：2025-01-13 15:44:30 瀏覽：412

電腦電腦直連通訊ftp 發布：2025-01-13 15:38:03 瀏覽：717

nvm存儲發布：2025-01-13 15:36:19 瀏覽：552

京東架構師緩存經驗發布：2025-01-13 15:33:00 瀏覽：726

android圖片顏色發布：2025-01-13 15:26:09 瀏覽：268

國家稅務總局電腦伺服器發布：2025-01-13 15:10:24 瀏覽：596

金立老款機的開機密碼是多少發布：2025-01-13 15:04:45 瀏覽：456

湖南網上辦稅初始密碼多少發布：2025-01-13 15:02:49 瀏覽：417

怎麼使用筆記本連接伺服器發布：2025-01-13 15:02:48 瀏覽：705

長城cs75plus選哪個配置發布：2025-01-13 14:54:05 瀏覽：22

python多進程與多線程

與python多進程與多線程相關的資訊