我欲封天耳根小说零,大主宰之灵路天蚕土豆

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營(yíng)銷解決方案

Python多線程、多進(jìn)程詳細(xì)整理

線程與進(jìn)程的區(qū)別

進(jìn)程（process）和線程（thread）是操作系統(tǒng)的基本概念，但是它們比較抽象，不容易掌握。關(guān)于多進(jìn)程和多線程，教科書上最經(jīng)典的一句話是“進(jìn)程是資源分配的最小單位，線程是CPU調(diào)度的最小單位”。線程是程序中一個(gè)單一的順序控制流程。進(jìn)程內(nèi)一個(gè)相對(duì)獨(dú)立的、可調(diào)度的執(zhí)行單元，是系統(tǒng)獨(dú)立調(diào)度和分派CPU的基本單位指運(yùn)行中的程序的調(diào)度單位。在單個(gè)程序中同時(shí)運(yùn)行多個(gè)線程完成不同的工作，稱為多線程。

進(jìn)程和線程區(qū)別

進(jìn)程是資源分配的基本單位。所有與該進(jìn)程有關(guān)的資源，都被記錄在進(jìn)程控制塊PCB中。以表示該進(jìn)程擁有這些資源或正在使用它們。另外，進(jìn)程也是搶占處理機(jī)的調(diào)度單位，它擁有一個(gè)完整的虛擬地址空間。當(dāng)進(jìn)程發(fā)生調(diào)度時(shí)，不同的進(jìn)程擁有不同的虛擬地址空間，而同一進(jìn)程內(nèi)的不同線程共享同一地址空間。

與進(jìn)程相對(duì)應(yīng)，線程與資源分配無(wú)關(guān)，它屬于某一個(gè)進(jìn)程，并與進(jìn)程內(nèi)的其他線程一起共享進(jìn)程的資源。線程只由相關(guān)堆棧（系統(tǒng)?；蛴脩魲＃┘拇嫫骱途€程控制表TCB組成。寄存器可被用來(lái)存儲(chǔ)線程內(nèi)的局部變量，但不能存儲(chǔ)其他線程的相關(guān)變量。

通常在一個(gè)進(jìn)程中可以包含若干個(gè)線程，它們可以利用進(jìn)程所擁有的資源。在引入線程的操作系統(tǒng)中，通常都是把進(jìn)程作為分配資源的基本單位，而把線程作為獨(dú)立運(yùn)行和獨(dú)立調(diào)度的基本單位。

由于線程比進(jìn)程更小，基本上不擁有系統(tǒng)資源，故對(duì)它的調(diào)度所付出的開銷就會(huì)小得多，能更高效的提高系統(tǒng)內(nèi)多個(gè)程序間并發(fā)執(zhí)行的程度，從而顯著提高系統(tǒng)資源的利用率和吞吐量。

因而近年來(lái)推出的通用操作系統(tǒng)都引入了線程，以便進(jìn)一步提高系統(tǒng)的并發(fā)性，并把它視為現(xiàn)代操作系統(tǒng)的一個(gè)重要指標(biāo)。

線程與進(jìn)程的區(qū)別可以歸納為以下4點(diǎn)：

地址空間和其它資源（如打開文件）：進(jìn)程間相互獨(dú)立，同一進(jìn)程的各線程間共享。某進(jìn)程內(nèi)的線程在其它進(jìn)程不可見(jiàn)。
通信：進(jìn)程間通信IPC，線程間可以直接讀寫進(jìn)程數(shù)據(jù)段（如全局變量）來(lái)進(jìn)行通信——需要進(jìn)程同步和互斥手段的輔助，以保證數(shù)據(jù)的一致性。
調(diào)度和切換：線程上下文切換比進(jìn)程上下文切換要快得多。
在多線程OS中，進(jìn)程不是一個(gè)可執(zhí)行的實(shí)體。

多進(jìn)程和多線程的比較

對(duì)比維度	多進(jìn)程	多線程	總結(jié)
數(shù)據(jù)共享、同步	數(shù)據(jù)共享復(fù)雜，同步簡(jiǎn)單	數(shù)據(jù)共享簡(jiǎn)單，同步復(fù)雜	各有優(yōu)劣
內(nèi)存、CPU	占用內(nèi)存多，切換復(fù)雜，CPU利用率低	占用內(nèi)存少，切換簡(jiǎn)單，CPU利用率高	線程占優(yōu)
創(chuàng)建、銷毀、切換	復(fù)雜，速度慢	簡(jiǎn)單，速度快	線程占優(yōu)
編程、調(diào)試	編程簡(jiǎn)單，調(diào)試簡(jiǎn)單	編程復(fù)雜，調(diào)試復(fù)雜	進(jìn)程占優(yōu)
可靠性	進(jìn)程間不會(huì)互相影響	一個(gè)線程掛掉將導(dǎo)致整個(gè)進(jìn)程掛掉	進(jìn)程占優(yōu)
分布式	適用于多核、多機(jī)，擴(kuò)展到多臺(tái)機(jī)器簡(jiǎn)單	適合于多核	進(jìn)程占優(yōu)

總結(jié)，進(jìn)程和線程還可以類比為火車和車廂：

線程在進(jìn)程下行進(jìn)（單純的車廂無(wú)法運(yùn)行）
一個(gè)進(jìn)程可以包含多個(gè)線程（一輛火車可以有多個(gè)車廂）
不同進(jìn)程間數(shù)據(jù)很難共享（一輛火車上的乘客很難換到另外一輛火車，比如站點(diǎn)換乘）
同一進(jìn)程下不同線程間數(shù)據(jù)很易共享（A車廂換到B車廂很容易）
進(jìn)程要比線程消耗更多的計(jì)算機(jī)資源（采用多列火車相比多個(gè)車廂更耗資源）
進(jìn)程間不會(huì)相互影響，一個(gè)線程掛掉將導(dǎo)致整個(gè)進(jìn)程掛掉（一列火車不會(huì)影響到另外一列火車，但是如果一列火車上中間的一節(jié)車廂著火了，將影響到該趟火車的所有車廂）
進(jìn)程可以拓展到多機(jī)，進(jìn)程最多適合多核（不同火車可以開在多個(gè)軌道上，同一火車的車廂不能在行進(jìn)的不同的軌道上）
進(jìn)程使用的內(nèi)存地址可以上鎖，即一個(gè)線程使用某些共享內(nèi)存時(shí)，其他線程必須等它結(jié)束，才能使用這一塊內(nèi)存。（比如火車上的洗手間）－”互斥鎖（mutex）”
進(jìn)程使用的內(nèi)存地址可以限定使用量（比如火車上的餐廳，最多只允許多少人進(jìn)入，如果滿了需要在門口等，等有人出來(lái)了才能進(jìn)去）－“信號(hào)量（semaphore）”

Python全局解釋器鎖GIL

全局解釋器鎖（英語(yǔ)：Global Interpreter Lock，縮寫GIL），并不是Python的特性，它是在實(shí)現(xiàn)Python解析器（CPython）時(shí)所引入的一個(gè)概念。由于CPython是大部分環(huán)境下默認(rèn)的Python執(zhí)行環(huán)境。所以在很多人的概念里CPython就是Python，也就想當(dāng)然的把GIL歸結(jié)為Python語(yǔ)言的缺陷。那么CPython實(shí)現(xiàn)中的GIL又是什么呢？來(lái)看看官方的解釋：

The mechanism used by the CPython interpreter to assure that only one thread executes Python bytecode at a time. This simplifies the CPython implementation by making the object model (including critical built-in types such as dict) implicitly safe against concurrent access. Locking the entire interpreter makes it easier for the interpreter to be multi-threaded, at the expense of much of the parallelism afforded by multi-processor machines.

Python代碼的執(zhí)行由Python 虛擬機(jī)(也叫解釋器主循環(huán)，CPython版本)來(lái)控制，Python 在設(shè)計(jì)之初就考慮到要在解釋器的主循環(huán)中，同時(shí)只有一個(gè)線程在執(zhí)行，即在任意時(shí)刻，只有一個(gè)線程在解釋器中運(yùn)行。對(duì)Python 虛擬機(jī)的訪問(wèn)由全局解釋器鎖（GIL）來(lái)控制，正是這個(gè)鎖能保證同一時(shí)刻只有一個(gè)線程在運(yùn)行。

GIL 有什么好處？簡(jiǎn)單來(lái)說(shuō)，它在單線程的情況更快，并且在和 C 庫(kù)結(jié)合時(shí)更方便，而且不用考慮線程安全問(wèn)題，這也是早期 Python 最常見(jiàn)的應(yīng)用場(chǎng)景和優(yōu)勢(shì)。另外，GIL的設(shè)計(jì)簡(jiǎn)化了CPython的實(shí)現(xiàn)，使得對(duì)象模型，包括關(guān)鍵的內(nèi)建類型如字典，都是隱含可以并發(fā)訪問(wèn)的。鎖住全局解釋器使得比較容易的實(shí)現(xiàn)對(duì)多線程的支持，但也損失了多處理器主機(jī)的并行計(jì)算能力。

在多線程環(huán)境中，Python 虛擬機(jī)按以下方式執(zhí)行：

設(shè)置GIL
切換到一個(gè)線程去運(yùn)行
運(yùn)行直至指定數(shù)量的字節(jié)碼指令，或者線程主動(dòng)讓出控制（可以調(diào)用sleep(0)）
把線程設(shè)置為睡眠狀態(tài)
解鎖GIL
再次重復(fù)以上所有步驟

Python3.2前，GIL的釋放邏輯是當(dāng)前線程遇見(jiàn)IO操作或者ticks計(jì)數(shù)達(dá)到100（ticks可以看作是python自身的一個(gè)計(jì)數(shù)器，專門做用于GIL，每次釋放后歸零，這個(gè)計(jì)數(shù)可以通過(guò) sys.setcheckinterval 來(lái)調(diào)整），進(jìn)行釋放。因?yàn)橛?jì)算密集型線程在釋放GIL之后又會(huì)立即去申請(qǐng)GIL，并且通常在其它線程還沒(méi)有調(diào)度完之前它就已經(jīng)重新獲取到了GIL，就會(huì)導(dǎo)致一旦計(jì)算密集型線程獲得了GIL，那么它在很長(zhǎng)一段時(shí)間內(nèi)都將占據(jù)GIL，甚至一直到該線程執(zhí)行結(jié)束。

Python 3.2開始使用新的GIL。新的GIL實(shí)現(xiàn)中用一個(gè)固定的超時(shí)時(shí)間來(lái)指示當(dāng)前的線程放棄全局鎖。在當(dāng)前線程保持這個(gè)鎖，且其他線程請(qǐng)求這個(gè)鎖時(shí)，當(dāng)前線程就會(huì)在5毫秒后被強(qiáng)制釋放該鎖。該改進(jìn)在單核的情況下，對(duì)于單個(gè)線程長(zhǎng)期占用GIL的情況有所好轉(zhuǎn)。

在單核CPU上，數(shù)百次的間隔檢查才會(huì)導(dǎo)致一次線程切換。在多核CPU上，存在嚴(yán)重的線程顛簸（thrashing）。而每次釋放GIL鎖，線程進(jìn)行鎖競(jìng)爭(zhēng)、切換線程，會(huì)消耗資源。單核下多線程，每次釋放GIL，喚醒的那個(gè)線程都能獲取到GIL鎖，所以能夠無(wú)縫執(zhí)行，但多核下，CPU0釋放GIL后，其他CPU上的線程都會(huì)進(jìn)行競(jìng)爭(zhēng)，但GIL可能會(huì)馬上又被CPU0拿到，導(dǎo)致其他幾個(gè)CPU上被喚醒后的線程會(huì)醒著等待到切換時(shí)間后又進(jìn)入待調(diào)度狀態(tài)，這樣會(huì)造成線程顛簸(thrashing)，導(dǎo)致效率更低。

另外，從上面的實(shí)現(xiàn)機(jī)制可以推導(dǎo)出，Python的多線程對(duì)IO密集型代碼要比CPU密集型代碼更加友好。

針對(duì)GIL的應(yīng)對(duì)措施：

使用更高版本Python（對(duì)GIL機(jī)制進(jìn)行了優(yōu)化）
使用多進(jìn)程替換多線程（多進(jìn)程之間沒(méi)有GIL，但是進(jìn)程本身的資源消耗較多）
指定cpu運(yùn)行線程（使用affinity模塊）
使用Jython、IronPython等無(wú)GIL解釋器
全I(xiàn)O密集型任務(wù)時(shí)才使用多線程
使用協(xié)程（高效的單線程模式，也稱微線程；通常與多進(jìn)程配合使用）
將關(guān)鍵組件用C/C++編寫為Python擴(kuò)展，通過(guò)ctypes使Python程序直接調(diào)用C語(yǔ)言編譯的動(dòng)態(tài)鏈接庫(kù)的導(dǎo)出函數(shù)。（with nogil調(diào)出GIL限制）

Python的多進(jìn)程包multiprocessing

Python的threading包主要運(yùn)用多線程的開發(fā)，但由于GIL的存在，Python中的多線程其實(shí)并不是真正的多線程，如果想要充分地使用多核CPU的資源，大部分情況需要使用多進(jìn)程。在Python 2.6版本的時(shí)候引入了multiprocessing包，它完整的復(fù)制了一套threading所提供的接口方便遷移。唯一的不同就是它使用了多進(jìn)程而不是多線程。每個(gè)進(jìn)程有自己的獨(dú)立的GIL，因此也不會(huì)出現(xiàn)進(jìn)程之間的GIL爭(zhēng)搶。

借助這個(gè)multiprocessing，你可以輕松完成從單進(jìn)程到并發(fā)執(zhí)行的轉(zhuǎn)換。multiprocessing支持子進(jìn)程、通信和共享數(shù)據(jù)、執(zhí)行不同形式的同步，提供了Process、Queue、Pipe、Lock等組件。

Multiprocessing產(chǎn)生的背景

除了應(yīng)對(duì)Python的GIL以外，產(chǎn)生multiprocessing的另外一個(gè)原因時(shí)Windows操作系統(tǒng)與Linux/Unix系統(tǒng)的不一致。

Unix/Linux操作系統(tǒng)提供了一個(gè)fork()系統(tǒng)調(diào)用，它非常特殊。普通的函數(shù)，調(diào)用一次，返回一次，但是fork()調(diào)用一次，返回兩次，因?yàn)椴僮飨到y(tǒng)自動(dòng)把當(dāng)前進(jìn)程（父進(jìn)程）復(fù)制了一份（子進(jìn)程），然后，分別在父進(jìn)程和子進(jìn)程內(nèi)返回。子進(jìn)程永遠(yuǎn)返回0，而父進(jìn)程返回子進(jìn)程的ID。這樣做的理由是，一個(gè)父進(jìn)程可以fork出很多子進(jìn)程，所以，父進(jìn)程要記下每個(gè)子進(jìn)程的ID，而子進(jìn)程只需要調(diào)用getpid()就可以拿到父進(jìn)程的ID。

Python的os模塊封裝了常見(jiàn)的系統(tǒng)調(diào)用，其中就包括fork，可以在Python程序中輕松創(chuàng)建子進(jìn)程：

import os
print('Process (%s) start...' % os.getpid())
\# Only works on Unix/Linux/Mac:
pid = os.fork()
if pid == 0:
    print('I am child process (%s) and my parent is %s.' % (os.getpid(), os.getppid()))
else:
    print('I (%s) just created a child process (%s).' % (os.getpid(), pid))

上述代碼在Linux、Unix和Mac上的執(zhí)行結(jié)果為：

Process (876) start...
I (876) just created a child process (877).
I am child process (877) and my parent is 876.

有了fork調(diào)用，一個(gè)進(jìn)程在接到新任務(wù)時(shí)就可以復(fù)制出一個(gè)子進(jìn)程來(lái)處理新任務(wù)，常見(jiàn)的Apache服務(wù)器就是由父進(jìn)程監(jiān)聽端口，每當(dāng)有新的http請(qǐng)求時(shí)，就fork出子進(jìn)程來(lái)處理新的http請(qǐng)求。

由于Windows沒(méi)有fork調(diào)用，上面的代碼在Windows上無(wú)法運(yùn)行。由于Python是跨平臺(tái)的，自然也應(yīng)該提供一個(gè)跨平臺(tái)的多進(jìn)程支持。multiprocessing模塊就是跨平臺(tái)版本的多進(jìn)程模塊。multiprocessing模塊封裝了fork()調(diào)用，使我們不需要關(guān)注fork()的細(xì)節(jié)。由于Windows沒(méi)有fork調(diào)用，因此，multiprocessing需要“模擬”出fork的效果。

multiprocessing常用組件及功能

創(chuàng)建管理進(jìn)程模塊：

Process（用于創(chuàng)建進(jìn)程）
Pool（用于創(chuàng)建管理進(jìn)程池）
Queue（用于進(jìn)程通信，資源共享）
Value，Array（用于進(jìn)程通信，資源共享）
Pipe（用于管道通信）
Manager（用于資源共享）

同步子進(jìn)程模塊：

Condition（條件變量）
Event（事件）
Lock（互斥鎖）
RLock（可重入的互斥鎖(同一個(gè)進(jìn)程可以多次獲得它，同時(shí)不會(huì)造成阻塞)
Semaphore（信號(hào)量）

接下來(lái)就一起來(lái)學(xué)習(xí)下每個(gè)組件及功能的具體使用方法。

Process（用于創(chuàng)建進(jìn)程）

multiprocessing模塊提供了一個(gè)Process類來(lái)代表一個(gè)進(jìn)程對(duì)象。

在multiprocessing中，每一個(gè)進(jìn)程都用一個(gè)Process類來(lái)表示。

構(gòu)造方法：Process([group [, target [, name [, args [, kwargs]]]]])

group：分組，實(shí)際上不使用，值始終為None
target：表示調(diào)用對(duì)象，即子進(jìn)程要執(zhí)行的任務(wù)，你可以傳入方法名
name：為子進(jìn)程設(shè)定名稱
args：要傳給target函數(shù)的位置參數(shù)，以元組方式進(jìn)行傳入。
kwargs：要傳給target函數(shù)的字典參數(shù)，以字典方式進(jìn)行傳入。

實(shí)例方法：

start()：?jiǎn)?dòng)進(jìn)程，并調(diào)用該子進(jìn)程中的p.run()
run()：進(jìn)程啟動(dòng)時(shí)運(yùn)行的方法，正是它去調(diào)用target指定的函數(shù)，我們自定義類的類中一定要實(shí)現(xiàn)該方法
terminate()：強(qiáng)制終止進(jìn)程p，不會(huì)進(jìn)行任何清理操作，如果p創(chuàng)建了子進(jìn)程，該子進(jìn)程就成了僵尸進(jìn)程，使用該方法需要特別小心這種情況。如果p還保存了一個(gè)鎖那么也將不會(huì)被釋放，進(jìn)而導(dǎo)致死鎖
is_alive()：返回進(jìn)程是否在運(yùn)行。如果p仍然運(yùn)行，返回True
join([timeout])：進(jìn)程同步，主進(jìn)程等待子進(jìn)程完成后再執(zhí)行后面的代碼。線程等待p終止（強(qiáng)調(diào)：是主線程處于等的狀態(tài)，而p是處于運(yùn)行的狀態(tài)）。timeout是可選的超時(shí)時(shí)間（超過(guò)這個(gè)時(shí)間，父線程不再等待子線程，繼續(xù)往下執(zhí)行），需要強(qiáng)調(diào)的是，p.join只能join住start開啟的進(jìn)程，而不能join住run開啟的進(jìn)程

屬性介紹：

daemon：默認(rèn)值為False，如果設(shè)為True，代表p為后臺(tái)運(yùn)行的守護(hù)進(jìn)程；當(dāng)p的父進(jìn)程終止時(shí)，p也隨之終止，并且設(shè)定為True后，p不能創(chuàng)建自己的新進(jìn)程；必須在p.start()之前設(shè)置
name：進(jìn)程的名稱
pid：進(jìn)程的pid
exitcode：進(jìn)程在運(yùn)行時(shí)為None、如果為–N，表示被信號(hào)N結(jié)束(了解即可)
authkey：進(jìn)程的身份驗(yàn)證鍵,默認(rèn)是由os.urandom()隨機(jī)生成的32字符的字符串。這個(gè)鍵的用途是為涉及網(wǎng)絡(luò)連接的底層進(jìn)程間通信提供安全性，這類連接只有在具有相同的身份驗(yàn)證鍵時(shí)才能成功（了解即可）

使用示例：（注意：在windows中Process()必須放到if name == ‘main’:下）

from multiprocessing import Process
import os
def run_proc(name):
    print('Run child process %s (%s)...' % (name, os.getpid()))
if __name__=='__main__':
    print('Parent process %s.' % os.getpid())
    p = Process(target=run_proc, args=('test',))
    print('Child process will start.')
    p.start()
    p.join()
print('Child process end.')

Pool（用于創(chuàng)建管理進(jìn)程池）

Pool類用于需要執(zhí)行的目標(biāo)很多，而手動(dòng)限制進(jìn)程數(shù)量又太繁瑣時(shí)，如果目標(biāo)少且不用控制進(jìn)程數(shù)量則可以用Process類。Pool可以提供指定數(shù)量的進(jìn)程，供用戶調(diào)用，當(dāng)有新的請(qǐng)求提交到Pool中時(shí)，如果池還沒(méi)有滿，那么就會(huì)創(chuàng)建一個(gè)新的進(jìn)程用來(lái)執(zhí)行該請(qǐng)求；但如果池中的進(jìn)程數(shù)已經(jīng)達(dá)到規(guī)定最大值，那么該請(qǐng)求就會(huì)等待，直到池中有進(jìn)程結(jié)束，就重用進(jìn)程池中的進(jìn)程。

構(gòu)造方法：Pool([processes[, initializer[, initargs[, maxtasksperchild[, context]]]]])

processes ：要?jiǎng)?chuàng)建的進(jìn)程數(shù)，如果省略，將默認(rèn)使用cpu_count()返回的數(shù)量。
initializer：每個(gè)工作進(jìn)程啟動(dòng)時(shí)要執(zhí)行的可調(diào)用對(duì)象，默認(rèn)為None。如果initializer是None，那么每一個(gè)工作進(jìn)程在開始的時(shí)候會(huì)調(diào)用initializer(*initargs)。
initargs：是要傳給initializer的參數(shù)組。
maxtasksperchild：工作進(jìn)程退出之前可以完成的任務(wù)數(shù)，完成后用一個(gè)新的工作進(jìn)程來(lái)替代原進(jìn)程，來(lái)讓閑置的資源被釋放。maxtasksperchild默認(rèn)是None，意味著只要Pool存在工作進(jìn)程就會(huì)一直存活。
context: 用在制定工作進(jìn)程啟動(dòng)時(shí)的上下文，一般使用Pool() 或者一個(gè)context對(duì)象的Pool()方法來(lái)創(chuàng)建一個(gè)池，兩種方法都適當(dāng)?shù)脑O(shè)置了context。

實(shí)例方法：

apply(func[, args[, kwargs]])：在一個(gè)池工作進(jìn)程中執(zhí)行func(args,*kwargs),然后返回結(jié)果。需要強(qiáng)調(diào)的是：此操作并不會(huì)在所有池工作進(jìn)程中并執(zhí)行func函數(shù)。如果要通過(guò)不同參數(shù)并發(fā)地執(zhí)行func函數(shù)，必須從不同線程調(diào)用p.apply()函數(shù)或者使用p.apply_async()。它是阻塞的。apply很少使用
apply_async(func[, arg[, kwds={}[, callback=None]]])：在一個(gè)池工作進(jìn)程中執(zhí)行func(args,*kwargs),然后返回結(jié)果。此方法的結(jié)果是AsyncResult類的實(shí)例，callback是可調(diào)用對(duì)象，接收輸入?yún)?shù)。當(dāng)func的結(jié)果變?yōu)榭捎脮r(shí)，將理解傳遞給callback。callback禁止執(zhí)行任何阻塞操作，否則將接收其他異步操作中的結(jié)果。它是非阻塞。
map(func, iterable[, chunksize=None])：Pool類中的map方法，與內(nèi)置的map函數(shù)用法行為基本一致，它會(huì)使進(jìn)程阻塞直到返回結(jié)果。注意，雖然第二個(gè)參數(shù)是一個(gè)迭代器，但在實(shí)際使用中，必須在整個(gè)隊(duì)列都就緒后，程序才會(huì)運(yùn)行子進(jìn)程。
map_async(func, iterable[, chunksize=None])：map_async與map的關(guān)系同apply與apply_async
imap()：imap 與 map的區(qū)別是，map是當(dāng)所有的進(jìn)程都已經(jīng)執(zhí)行完了，并將結(jié)果返回了，imap()則是立即返回一個(gè)iterable可迭代對(duì)象。
imap_unordered()：不保證返回的結(jié)果順序與進(jìn)程添加的順序一致。
close()：關(guān)閉進(jìn)程池，防止進(jìn)一步操作。如果所有操作持續(xù)掛起，它們將在工作進(jìn)程終止前完成。
join()：等待所有工作進(jìn)程退出。此方法只能在close()或teminate()之后調(diào)用，讓其不再接受新的Process。
terminate()：結(jié)束工作進(jìn)程，不再處理未處理的任務(wù)。

方法apply_async()和map_async()的返回值是AsyncResul的實(shí)例obj。實(shí)例具有以下方法：

get()：返回結(jié)果，如果有必要?jiǎng)t等待結(jié)果到達(dá)。timeout是可選的。如果在指定時(shí)間內(nèi)還沒(méi)有到達(dá)，將引發(fā)異常。如果遠(yuǎn)程操作中引發(fā)了異常，它將在調(diào)用此方法時(shí)再次被引發(fā)。
ready()：如果調(diào)用完成，返回True
successful()：如果調(diào)用完成且沒(méi)有引發(fā)異常，返回True，如果在結(jié)果就緒之前調(diào)用此方法，引發(fā)異常
wait([timeout])：等待結(jié)果變?yōu)榭捎谩?
terminate()：立即終止所有工作進(jìn)程，同時(shí)不執(zhí)行任何清理或結(jié)束任何掛起工作。如果p被垃圾回收，將自動(dòng)調(diào)用此函數(shù)

\# -*- coding:utf-8 -*-
Queue（用于進(jìn)程通信，資源共享）
\# Pool+map
from multiprocessing import Pool
def test(i):
    print(i)
if __name__ == "__main__":
    lists = range(100)
    pool = Pool(8)
    pool.map(test, lists)
    pool.close()
    pool.join()

\# -*- coding:utf-8 -*-
\# 異步進(jìn)程池（非阻塞）
from multiprocessing import Pool
def test(i):
    print(i)
if __name__ == "__main__":
    pool = Pool(8)
    for i in range(100):
        '''
        For循環(huán)中執(zhí)行步驟：
        （1）循環(huán)遍歷，將100個(gè)子進(jìn)程添加到進(jìn)程池（相對(duì)父進(jìn)程會(huì)阻塞）
        （2）每次執(zhí)行8個(gè)子進(jìn)程，等一個(gè)子進(jìn)程執(zhí)行完后，立馬啟動(dòng)新的子進(jìn)程。（相對(duì)父進(jìn)程不阻塞）
        apply_async為異步進(jìn)程池寫法。異步指的是啟動(dòng)子進(jìn)程的過(guò)程，與父進(jìn)程本身的執(zhí)行（print）是異步的，而For循環(huán)中往進(jìn)程池添加子進(jìn)程的過(guò)程，與父進(jìn)程本身的執(zhí)行卻是同步的。
        '''
        pool.apply_async(test, args=(i,))  # 維持執(zhí)行的進(jìn)程總數(shù)為8，當(dāng)一個(gè)進(jìn)程執(zhí)行完后啟動(dòng)一個(gè)新進(jìn)程.
    print("test")
    pool.close()
    pool.join()

\# -*- coding:utf-8 -*-
\# 異步進(jìn)程池（非阻塞）
from multiprocessing import Pool
def test(i):
    print(i)
if __name__ == "__main__":
    pool = Pool(8)
    for i in range(100):
        '''
            實(shí)際測(cè)試發(fā)現(xiàn)，for循環(huán)內(nèi)部執(zhí)行步驟：
            （1）遍歷100個(gè)可迭代對(duì)象，往進(jìn)程池放一個(gè)子進(jìn)程
            （2）執(zhí)行這個(gè)子進(jìn)程，等子進(jìn)程執(zhí)行完畢，再往進(jìn)程池放一個(gè)子進(jìn)程，再執(zhí)行。（同時(shí)只執(zhí)行一個(gè)子進(jìn)程）
            for循環(huán)執(zhí)行完畢，再執(zhí)行print函數(shù)。
        '''
        pool.apply(test, args=(i,))  # 維持執(zhí)行的進(jìn)程總數(shù)為8，當(dāng)一個(gè)進(jìn)程執(zhí)行完后啟動(dòng)一個(gè)新進(jìn)程.
    print("test")
    pool.close()
    pool.join()

Queue（用于進(jìn)程通信，資源共享）

在使用多進(jìn)程的過(guò)程中，最好不要使用共享資源。普通的全局變量是不能被子進(jìn)程所共享的，只有通過(guò)Multiprocessing組件構(gòu)造的數(shù)據(jù)結(jié)構(gòu)可以被共享。

Queue是用來(lái)創(chuàng)建進(jìn)程間資源共享的隊(duì)列的類，使用Queue可以達(dá)到多進(jìn)程間數(shù)據(jù)傳遞的功能（缺點(diǎn)：只適用Process類，不能在Pool進(jìn)程池中使用）。

構(gòu)造方法：Queue([maxsize])

maxsize是隊(duì)列中允許最大項(xiàng)數(shù)，省略則無(wú)大小限制。

實(shí)例方法：

put()：用以插入數(shù)據(jù)到隊(duì)列。put方法還有兩個(gè)可選參數(shù)：blocked和timeout。如果blocked為True（默認(rèn)值），并且timeout為正值，該方法會(huì)阻塞timeout指定的時(shí)間，直到該隊(duì)列有剩余的空間。如果超時(shí)，會(huì)拋出Queue.Full異常。如果blocked為False，但該Queue已滿，會(huì)立即拋出Queue.Full異常。
get()：可以從隊(duì)列讀取并且刪除一個(gè)元素。get方法有兩個(gè)可選參數(shù)：blocked和timeout。如果blocked為True（默認(rèn)值），并且timeout為正值，那么在等待時(shí)間內(nèi)沒(méi)有取到任何元素，會(huì)拋出Queue.Empty異常。如果blocked為False，有兩種情況存在，如果Queue有一個(gè)值可用，則立即返回該值，否則，如果隊(duì)列為空，則立即拋出Queue.Empty異常。若不希望在empty的時(shí)候拋出異常，令blocked為True或者參數(shù)全部置空即可。
get_nowait()：同q.get(False)
put_nowait()：同q.put(False)
empty()：調(diào)用此方法時(shí)q為空則返回True，該結(jié)果不可靠，比如在返回True的過(guò)程中，如果隊(duì)列中又加入了項(xiàng)目。
full()：調(diào)用此方法時(shí)q已滿則返回True，該結(jié)果不可靠，比如在返回True的過(guò)程中，如果隊(duì)列中的項(xiàng)目被取走。
qsize()：返回隊(duì)列中目前項(xiàng)目的正確數(shù)量，結(jié)果也不可靠，理由同q.empty()和q.full()一樣

使用示例：

from multiprocessing import Process, Queue
import os, time, random
def write(q):
    print('Process to write: %s' % os.getpid())
    for value in ['A', 'B', 'C']:
        print('Put %s to queue...' % value)
        q.put(value)
        time.sleep(random.random())
def read(q):
    print('Process to read: %s' % os.getpid())
    while True:
        value = q.get(True)
        print('Get %s from queue.' % value)
if __name__ == "__main__":
    q = Queue()
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))
    pw.start()
    pr.start()
    pw.join()  # 等待pw結(jié)束
    pr.terminate()  # pr進(jìn)程里是死循環(huán)，無(wú)法等待其結(jié)束，只能強(qiáng)行終止

JoinableQueue就像是一個(gè)Queue對(duì)象，但隊(duì)列允許項(xiàng)目的使用者通知生成者項(xiàng)目已經(jīng)被成功處理。通知進(jìn)程是使用共享的信號(hào)和條件變量來(lái)實(shí)現(xiàn)的。

構(gòu)造方法：JoinableQueue([maxsize])

maxsize：隊(duì)列中允許最大項(xiàng)數(shù)，省略則無(wú)大小限制。

實(shí)例方法

JoinableQueue的實(shí)例p除了與Queue對(duì)象相同的方法之外還具有：

task_done()：使用者使用此方法發(fā)出信號(hào)，表示q.get()的返回項(xiàng)目已經(jīng)被處理。如果調(diào)用此方法的次數(shù)大于從隊(duì)列中刪除項(xiàng)目的數(shù)量，將引發(fā)ValueError異常
join():生產(chǎn)者調(diào)用此方法進(jìn)行阻塞，直到隊(duì)列中所有的項(xiàng)目均被處理。阻塞將持續(xù)到隊(duì)列中的每個(gè)項(xiàng)目均調(diào)用q.task_done（）方法為止

使用示例：

\# -*- coding:utf-8 -*-
from multiprocessing import Process, JoinableQueue
import time, random
def consumer(q):
    while True:
        res = q.get()
        print('消費(fèi)者拿到了 %s' % res)
        q.task_done()
def producer(seq, q):
    for item in seq:
        time.sleep(random.randrange(1,2))
        q.put(item)
        print('生產(chǎn)者做好了 %s' % item)
    q.join()
if __name__ == "__main__":
    q = JoinableQueue()
    seq = ('產(chǎn)品%s' % i for i in range(5))
    p = Process(target=consumer, args=(q,))
    p.daemon = True  # 設(shè)置為守護(hù)進(jìn)程，在主線程停止時(shí)p也停止，但是不用擔(dān)心，producer內(nèi)調(diào)用q.join保證了consumer已經(jīng)處理完隊(duì)列中的所有元素
    p.start()
    producer(seq, q)
    print('主線程')

Value，Array（用于進(jìn)程通信，資源共享）

multiprocessing 中Value和Array的實(shí)現(xiàn)原理都是在共享內(nèi)存中創(chuàng)建ctypes()對(duì)象來(lái)達(dá)到共享數(shù)據(jù)的目的，兩者實(shí)現(xiàn)方法大同小異，只是選用不同的ctypes數(shù)據(jù)類型而已。

Value

構(gòu)造方法：Value((typecode_or_type, args[, lock])

typecode_or_type：定義ctypes()對(duì)象的類型，可以傳Type code或 C Type，具體對(duì)照表見(jiàn)下文。
args：傳遞給typecode_or_type構(gòu)造函數(shù)的參數(shù)
lock：默認(rèn)為True，創(chuàng)建一個(gè)互斥鎖來(lái)限制對(duì)Value對(duì)象的訪問(wèn)，如果傳入一個(gè)鎖，如Lock或RLock的實(shí)例，將用于同步。如果傳入False，Value的實(shí)例就不會(huì)被鎖保護(hù)，它將不是進(jìn)程安全的。

typecode_or_type支持的類型：

| Type code | C Type             | Python Type       | Minimum size in bytes |
| --------- | ------------------ | ----------------- | --------------------- |
| `'b'`     | signed char        | int               | 1                     |
| `'B'`     | unsigned char      | int               | 1                     |
| `'u'`     | Py_UNICODE         | Unicode character | 2                     |
| `'h'`     | signed short       | int               | 2                     |
| `'H'`     | unsigned short     | int               | 2                     |
| `'i'`     | signed int         | int               | 2                     |
| `'I'`     | unsigned int       | int               | 2                     |
| `'l'`     | signed long        | int               | 4                     |
| `'L'`     | unsigned long      | int               | 4                     |
| `'q'`     | signed long long   | int               | 8                     |
| `'Q'`     | unsigned long long | int               | 8                     |
| `'f'`     | float              | float             | 4                     |
| `'d'`     | double             | float             | 8                     |

參考地址：https://docs.python.org/3/library/array.html

Array

構(gòu)造方法：Array(typecode_or_type, size_or_initializer, **kwds[, lock])

typecode_or_type：同上
size_or_initializer：如果它是一個(gè)整數(shù)，那么它確定數(shù)組的長(zhǎng)度，并且數(shù)組將被初始化為零。否則，size_or_initializer是用于初始化數(shù)組的序列，其長(zhǎng)度決定數(shù)組的長(zhǎng)度。
kwds：傳遞給typecode_or_type構(gòu)造函數(shù)的參數(shù)
lock：同上

使用示例：

import multiprocessing
def f(n, a):
    n.value = 3.14
    a[0] = 5
if __name__ == '__main__':
    num = multiprocessing.Value('d', 0.0)
    arr = multiprocessing.Array('i', range(10))
    p = multiprocessing.Process(target=f, args=(num, arr))
    p.start()
    p.join()
    print(num.value)
    print(arr[:])

注意：Value和Array只適用于Process類。

Pipe（用于管道通信）

多進(jìn)程還有一種數(shù)據(jù)傳遞方式叫管道原理和 Queue相同。Pipe可以在進(jìn)程之間創(chuàng)建一條管道，并返回元組（conn1,conn2）,其中conn1，conn2表示管道兩端的連接對(duì)象，強(qiáng)調(diào)一點(diǎn)：必須在產(chǎn)生Process對(duì)象之前產(chǎn)生管道。

構(gòu)造方法：Pipe([duplex])

dumplex:默認(rèn)管道是全雙工的，如果將duplex射成False，conn1只能用于接收，conn2只能用于發(fā)送。

實(shí)例方法：

send(obj)：通過(guò)連接發(fā)送對(duì)象。obj是與序
文章題目：Python多線程、多進(jìn)程詳細(xì)整理
鏈接地址：http://m.fisionsoft.com.cn/article/cccihhj.html

新聞中心

線程與進(jìn)程的區(qū)別

進(jìn)程和線程區(qū)別

多進(jìn)程和多線程的比較

Python全局解釋器鎖GIL

Python的多進(jìn)程包multiprocessing

Multiprocessing產(chǎn)生的背景

multiprocessing常用組件及功能

Process（用于創(chuàng)建進(jìn)程）

Pool（用于創(chuàng)建管理進(jìn)程池）

Queue（用于進(jìn)程通信，資源共享）

Value，Array（用于進(jìn)程通信，資源共享）

Value

Array

Pipe（用于管道通信）

其他資訊

Queue（用于進(jìn)程通信，資源共享）

Value，Array（用于進(jìn)程通信，資源共享）