建站
咨詢
售后
建站咨詢
新聞中心
線程與進(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://www.fisionsoft.com.cn/article/cccihhj.html
