python進程通信

⑴ python進程間通信怎麼理解

在2.6才開始使用
multiprocessing 是一個使用方法類似threading模塊的進程模塊。允許程序員做並行開發。並且可以在UNIX和Windows下運行。
通過創建一個Process 類型並且通過調用call()方法spawn一個進程。

一個比較簡單的例子：
#!/usr/bin/env python

from multiprocessing import Process
import time
def f(name):
time.sleep(1)
print 'hello ',name
print os.getppid() #取得父進程ID
print os.getpid() #取得進程ID
process_list = []
if __name__ == '__main__':
for i in range(10):
p = Process(target=f,args=(i,))
p.start()
process_list.append(p)
for j in process_list:
j.join()

進程間通信：
有兩種主要的方式：Queue、Pipe
1- Queue類幾乎就是Queue.Queue的復制，示例：
#!/usr/bin/env python

from multiprocessing import Process,Queue
import time
def f(name):
time.sleep(1)
q.put(['hello'+str(name)])
process_list = []
q = Queue()
if __name__ == '__main__':
for i in range(10):
p = Process(target=f,args=(i,))
p.start()
process_list.append(p)
for j in process_list:
j.join()
for i in range(10):
print q.get()
2- Pipe 管道
#!/usr/bin/env python

from multiprocessing import Process,Pipe
import time
import os

def f(conn,name):
time.sleep(1)
conn.send(['hello'+str(name)])
print os.getppid(),'-----------',os.getpid()
process_list = []
parent_conn,child_conn = Pipe()
if __name__ == '__main__':
for i in range(10):
p = Process(target=f,args=(child_conn,i))
p.start()
process_list.append(p)
for j in process_list:
j.join()
for p in range(10):
print parent_conn.recv()
Pipe()返回兩個連接類，代表兩個方向。如果兩個進程在管道的兩邊同時讀或同時寫，會有可能造成corruption.

進程間同步
multiprocessing contains equivalents of all the synchronization primitives from threading.
例如，可以加一個鎖，以使某一時刻只有一個進程print
#!/usr/bin/env python

from multiprocessing import Process,Lock
import time
import os

def f(name):
lock.acquire()
time.sleep(1)
print 'hello--'+str(name)
print os.getppid(),'-----------',os.getpid()
lock.release()
process_list = []
lock = Lock()
if __name__ == '__main__':
for i in range(10):
p = Process(target=f,args=(i,))
p.start()
process_list.append(p)
for j in process_list:
j.join()

進程間共享狀態 Sharing state between processes
當然盡最大可能防止使用共享狀態，但最終有可能會使用到.
1-共享內存
可以通過使用Value或者Array把數據存儲在一個共享的內存表中
#!/usr/bin/env python

from multiprocessing import Process,Value,Array
import time
import os

def f(n,a,name):
time.sleep(1)
n.value = name * name
for i in range(len(a)):
a[i] = -i
process_list = []
if __name__ == '__main__':
num = Value('d',0.0)
arr = Array('i',range(10))
for i in range(10):
p = Process(target=f,args=(num,arr,i))
p.start()
process_list.append(p)
for j in process_list:
j.join()
print num.value
print arr[:]
輸出：
jimin@Jimin:~/projects$ python pp.py
81.0
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
'd'和'i'參數是num和arr用來設置類型，d表示一個雙精浮點類型，i表示一個帶符號的整型。
更加靈活的共享內存可以使用multiprocessing.sharectypes模塊

Server process
Manager()返回一個manager類型，控制一個server process，可以允許其它進程通過代理復制一些python objects
支持list,dict,Namespace,Lock,Semaphore,BoundedSemaphore,Condition,Event,Queue,Value,Array
例如：
#!/usr/bin/env python

from multiprocessing import Process,Manager
import time
import os

def f(d,name):
time.sleep(1)
d[name] = name * name
print d
process_list = []
if __name__ == '__main__':
manager = Manager()
d = manager.dict()
for i in range(10):
p = Process(target=f,args=(d,i))
p.start()
process_list.append(p)
for j in process_list:
j.join()
print d
輸出結果：
{2: 4}
{2: 4, 3: 9}
{2: 4, 3: 9, 4: 16}
{1: 1, 2: 4, 3: 9, 4: 16}
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 8: 64}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
Server process managers比共享內存方法更加的靈活，一個單獨的manager可以被同一網路的不同計算機的多個進程共享。
比共享內存更加的緩慢

使用工作池Using a pool of workers
Pool類代表 a pool of worker processes.
It has methods which allows tasks to be offloaded to the worker processes in a few different ways.

⑵ 一篇文章帶你深度解析Python線程和進程

使用Python中的線程模塊，能夠同時運行程序的不同部分，並簡化設計。如果你已經入門Python，並且想用線程來提升程序運行速度的話，希望這篇教程會對你有所幫助。

線程與進程

什麼是進程

進程是系統進行資源分配和調度的一個獨立單位 進程是具有一定獨立功能的程序關於某個數據集合上的一次運行活動,進程是系統進行資源分配和調度的一個獨立單位。每個進程都有自己的獨立內存空間，不同進程通過進程間通信來通信。由於進程比較重量，占據獨立的內存，所以上下文進程間的切換開銷（棧、寄存器、虛擬內存、文件句柄等）比較大，但相對比較穩定安全。

什麼是線程

CPU調度和分派的基本單位 線程是進程的一個實體，是CPU調度和分派的基本單位,它是比進程更小的能獨立運行的基本單位.線程自己基本上不擁有系統資源,只擁有一點在運行中必不可少的資源(如程序計數器,一組寄存器和棧),但是它可與同屬一個進程的其他的線程共享進程所擁有的全部資源。線程間通信主要通過共享內存，上下文切換很快，資源開銷較少，但相比進程不夠穩定容易丟失數據。

進程與線程的關系圖

線程與進程的區別：

進程

現實生活中，有很多的場景中的事情是同時進行的，比如開車的時候 手和腳共同來駕駛 汽車 ，比如唱歌跳舞也是同時進行的，再比如邊吃飯邊打電話；試想如果我們吃飯的時候有一個領導來電，我們肯定是立刻就接聽了。但是如果你吃完飯再接聽或者回電話，很可能會被開除。

注意：

多任務的概念

什麼叫 多任務 呢？簡單地說，就是操作系統可以同時運行多個任務。打個比方，你一邊在用瀏覽器上網，一邊在聽MP3，一邊在用Word趕作業，這就是多任務，至少同時有3個任務正在運行。還有很多任務悄悄地在後台同時運行著，只是桌面上沒有顯示而已。

現在，多核CPU已經非常普及了，但是，即使過去的單核CPU，也可以執行多任務。由於CPU執行代碼都是順序執行的，那麼，單核CPU是怎麼執行多任務的呢？

答案就是操作系統輪流讓各個任務交替執行，任務1執行0.01秒，切換到任務2，任務2執行0.01秒，再切換到任務3，執行0.01秒，這樣反復執行下去。表面上看，每個任務都是交替執行的，但是，由於CPU的執行速度實在是太快了，我們感覺就像所有任務都在同時執行一樣。

真正的並行執行多任務只能在多核CPU上實現，但是，由於任務數量遠遠多於CPU的核心數量，所以，操作系統也會自動把很多任務輪流調度到每個核心上執行。 其實就是CPU執行速度太快啦！以至於我們感受不到在輪流調度。

並行與並發

並行（Parallelism）

並行：指兩個或兩個以上事件（或線程）在同一時刻發生，是真正意義上的不同事件或線程在同一時刻，在不同CPU資源呢上（多核），同時執行。

特點

並發（Concurrency）

指一個物理CPU(也可以多個物理CPU) 在若幹道程序（或線程）之間多路復用，並發性是對有限物理資源強制行使多用戶共享以提高效率。

特點

multiprocess.Process模塊

process模塊是一個創建進程的模塊，藉助這個模塊，就可以完成進程的創建。

語法：Process([group [, target [, name [, args [, kwargs]]]]])

由該類實例化得到的對象，表示一個子進程中的任務（尚未啟動）。

注意：1. 必須使用關鍵字方式來指定參數；2. args指定的為傳給target函數的位置參數，是一個元祖形式，必須有逗號。

參數介紹：

group：參數未使用，默認值為None。

target：表示調用對象，即子進程要執行的任務。

args：表示調用的位置參數元祖。

kwargs：表示調用對象的字典。如kwargs = {'name':Jack, 'age':18}。

name：子進程名稱。

代碼：

除了上面這些開啟進程的方法之外，還有一種以繼承Process的方式開啟進程的方式：

通過上面的研究，我們千方百計實現了程序的非同步，讓多個任務可以同時在幾個進程中並發處理，他們之間的運行沒有順序，一旦開啟也不受我們控制。盡管並發編程讓我們能更加充分的利用IO資源，但是也給我們帶來了新的問題。

當多個進程使用同一份數據資源的時候，就會引發數據安全或順序混亂問題，我們可以考慮加鎖，我們以模擬搶票為例，來看看數據安全的重要性。

加鎖可以保證多個進程修改同一塊數據時，同一時間只能有一個任務可以進行修改，即串列的修改。加鎖犧牲了速度，但是卻保證了數據的安全。

因此我們最好找尋一種解決方案能夠兼顧：1、效率高（多個進程共享一塊內存的數據）2、幫我們處理好鎖問題。

mutiprocessing模塊為我們提供的基於消息的IPC通信機制：隊列和管道。隊列和管道都是將數據存放於內存中 隊列又是基於（管道+鎖）實現的，可以讓我們從復雜的鎖問題中解脫出來， 我們應該盡量避免使用共享數據，盡可能使用消息傳遞和隊列，避免處理復雜的同步和鎖問題，而且在進程數目增多時，往往可以獲得更好的可獲展性（ 後續擴展該內容 ）。

線程

Python的threading模塊

Python 供了幾個用於多線程編程的模塊，包括 thread, threading 和 Queue 等。thread 和 threading 模塊允許程序員創建和管理線程。thread 模塊 供了基本的線程和鎖的支持，而 threading 供了更高級別，功能更強的線程管理的功能。Queue 模塊允許用戶創建一個可以用於多個線程之間 共享數據的隊列數據結構。

python創建和執行線程

創建線程代碼

1. 創建方法一:

2. 創建方法二:

進程和線程都是實現多任務的一種方式，例如：在同一台計算機上能同時運行多個QQ（進程),一個QQ可以打開多個聊天窗口（線程）。資源共享：進程不能共享資源，而線程共享所在進程的地址空間和其他資源，同時，線程有自己的棧和棧指針。所以在一個進程內的所有線程共享全局變數，但多線程對全局變數的更改會導致變數值得混亂。

代碼演示:

得到的結果是：

首先需要明確的一點是GIL並不是Python的特性，它是在實現Python解析器(CPython)時所引入的一個概念。就好比C++是一套語言（語法）標准，但是可以用不同的編譯器來編譯成可執行代碼。同樣一段代碼可以通過CPython，PyPy，Psyco等不同的Python執行環境來執行（其中的JPython就沒有GIL）。

那麼CPython實現中的GIL又是什麼呢？GIL全稱Global Interpreter Lock為了避免誤導，我們還是來看一下官方給出的解釋：

主要意思為:

因此，解釋器實際上被一個全局解釋器鎖保護著，它確保任何時候都只有一個Python線程執行。在多線程環境中，Python 虛擬機按以下方式執行:

由於GIL的存在，Python的多線程不能稱之為嚴格的多線程。因為 多線程下每個線程在執行的過程中都需要先獲取GIL，保證同一時刻只有一個線程在運行。

由於GIL的存在，即使是多線程，事實上同一時刻只能保證一個線程在運行， 既然這樣多線程的運行效率不就和單線程一樣了嗎，那為什麼還要使用多線程呢？

由於以前的電腦基本都是單核CPU，多線程和單線程幾乎看不出差別，可是由於計算機的迅速發展，現在的電腦幾乎都是多核CPU了，最少也是兩個核心數的，這時差別就出來了：通過之前的案例我們已經知道，即使在多核CPU中，多線程同一時刻也只有一個線程在運行，這樣不僅不能利用多核CPU的優勢，反而由於每個線程在多個CPU上是交替執行的，導致在不同CPU上切換時造成資源的浪費，反而會更慢。即原因是一個進程只存在一把gil鎖，當在執行多個線程時，內部會爭搶gil鎖，這會造成當某一個線程沒有搶到鎖的時候會讓cpu等待，進而不能合理利用多核cpu資源。

但是在使用多線程抓取網頁內容時，遇到IO阻塞時，正在執行的線程會暫時釋放GIL鎖，這時其它線程會利用這個空隙時間，執行自己的代碼，因此多線程抓取比單線程抓取性能要好，所以我們還是要使用多線程的。

GIL對多線程Python程序的影響

程序的性能受到計算密集型(CPU)的程序限制和I/O密集型的程序限制影響,那什麼是計算密集型和I/O密集型程序呢?

計算密集型：要進行大量的數值計算，例如進行上億的數字計算、計算圓周率、對視頻進行高清解碼等等。這種計算密集型任務雖然也可以用多任務完成，但是花費的主要時間在任務切換的時間，此時CPU執行任務的效率比較低。

IO密集型：涉及到網路請求(time.sleep())、磁碟IO的任務都是IO密集型任務，這類任務的特點是CPU消耗很少，任務的大部分時間都在等待IO操作完成（因為IO的速度遠遠低於CPU和內存的速度）。對於IO密集型任務，任務越多，CPU效率越高，但也有一個限度。

當然為了避免GIL對我們程序產生影響，我們也可以使用，線程鎖。

Lock&RLock

常用的資源共享鎖機制：有Lock、RLock、Semphore、Condition等，簡單給大家分享下Lock和RLock。

Lock

特點就是執行速度慢，但是保證了數據的安全性

RLock

使用鎖代碼操作不當就會產生死鎖的情況。

什麼是死鎖

死鎖：當線程A持有獨占鎖a，並嘗試去獲取獨占鎖b的同時，線程B持有獨占鎖b，並嘗試獲取獨占鎖a的情況下，就會發生AB兩個線程由於互相持有對方需要的鎖，而發生的阻塞現象，我們稱為死鎖。即死鎖是指多個進程因競爭資源而造成的一種僵局，若無外力作用，這些進程都將無法向前推進。

所以，在系統設計、進程調度等方面注意如何不讓這四個必要條件成立，如何確定資源的合理分配演算法，避免進程永久占據系統資源。

死鎖代碼

python線程間通信

如果各個線程之間各干各的，確實不需要通信，這樣的代碼也十分的簡單。但這一般是不可能的，至少線程要和主線程進行通信，不然計算結果等內容無法取回。而實際情況中要復雜的多，多個線程間需要交換數據，才能得到正確的執行結果。

python中Queue是消息隊列，提供線程間通信機制，python3中重名為為queue，queue模塊塊下提供了幾個阻塞隊列，這些隊列主要用於實現線程通信。

在 queue 模塊下主要提供了三個類，分別代表三種隊列，它們的主要區別就在於進隊列、出隊列的不同。

簡單代碼演示

此時代碼會阻塞，因為queue中內容已滿，此時可以在第四個queue.put('蘋果')後面添加timeout，則成為 queue.put('蘋果'，timeout=1)如果等待1秒鍾仍然是滿的就會拋出異常，可以捕獲異常。

同理如果隊列是空的，無法獲取到內容默認也會阻塞，如果不阻塞可以使用queue.get_nowait()。

在掌握了 Queue 阻塞隊列的特性之後，在下面程序中就可以利用 Queue 來實現線程通信了。

下面演示一個生產者和一個消費者，當然都可以多個

使用queue模塊，可在線程間進行通信，並保證了線程安全。

協程

協程，又稱微線程，纖程。英文名Coroutine。

協程是python個中另外一種實現多任務的方式，只不過比線程更小佔用更小執行單元（理解為需要的資源）。為啥說它是一個執行單元，因為它自帶CPU上下文。這樣只要在合適的時機， 我們可以把一個協程 切換到另一個協程。只要這個過程中保存或恢復 CPU上下文那麼程序還是可以運行的。

通俗的理解：在一個線程中的某個函數，可以在任何地方保存當前函數的一些臨時變數等信息，然後切換到另外一個函數中執行，注意不是通過調用函數的方式做到的，並且切換的次數以及什麼時候再切換到原來的函數都由開發者自己確定。

在實現多任務時，線程切換從系統層面遠不止保存和恢復 CPU上下文這么簡單。操作系統為了程序運行的高效性每個線程都有自己緩存Cache等等數據，操作系統還會幫你做這些數據的恢復操作。所以線程的切換非常耗性能。但是協程的切換只是單純的操作CPU的上下文，所以一秒鍾切換個上百萬次系統都抗的住。

greenlet與gevent

為了更好使用協程來完成多任務，除了使用原生的yield完成模擬協程的工作，其實python還有的greenlet模塊和gevent模塊，使實現協程變的更加簡單高效。

greenlet雖說實現了協程，但需要我們手工切換，太麻煩了，gevent是比greenlet更強大的並且能夠自動切換任務的模塊。

其原理是當一個greenlet遇到IO(指的是input output 輸入輸出，比如網路、文件操作等)操作時，比如訪問網路，就自動切換到其他的greenlet，等到IO操作完成，再在適當的時候切換回來繼續執行。

模擬耗時操作：

如果有耗時操作也可以換成，gevent中自己實現的模塊，這時候就需要打補丁了。

使用協程完成一個簡單的二手房信息的爬蟲代碼吧！

以下文章來源於Python專欄 ，作者宋宋

文章鏈接：https://mp.weixin.qq.com/s/2r3_ipU3HjdA5VnqSHjUnQ

⑶ python中的進程-實戰部分

如果想了解進程 可以先看一下這一篇 python中的進程-理論部分

python中的多線程無法利用多核優勢，如果想要充分地使用多核CPU的資源（os.cpu_count()查看），在python中大部分情況需要使用多進程。Python提供了multiprocessing。
multiprocessing模塊用來開啟子進程，並在子進程中執行我們定製的任務（比如函數），該模塊與多線程模塊threading的編程介面類似。

multiprocessing模塊的功能眾多：支持子進程、通信和共享數據、執行不同形式的同步，提供了Process、Queue、Pipe、Lock等組件。

需要再次強調的一點是：與線程不同，進程沒有任何共享狀態，進程修改的數據，改動僅限於該進程內。

創建進程的類 ：

參數介紹：

group參數未使用，值始終為None

target表示調用對象，即子進程要執行的任務

args表示調用對象的位置參數元組，args=(1,2,'tiga',)

kwargs表示調用對象的字典,kwargs={'name':'tiga','age':18}

name為子進程的名稱

方法介紹：

p.start()：啟動進程，並調用該子進程中的p.run()
p.run():進程啟動時運行的方法，正是它去調用target指定的函數，我們自定義類的類中一定要實現該方法

p.terminate():強制終止進程p，不會進行任何清理操作，如果p創建了子進程，該子進程就成了僵屍進程，使用該方法需要特別小心這種情況。如果p還保存了一個鎖那麼也將不會被釋放，進而導致死鎖
p.is_alive():如果p仍然運行，返回True

p.join([timeout]):主線程等待p終止（強調：是主線程處於等的狀態，而p是處於運行的狀態）。timeout是可選的超時時間，需要強調的是，p.join只能join住start開啟的進程，而不能join住run開啟的進程

屬性介紹：

注意：在windows中Process()必須放到# if __name__ == '__main__':下

創建並開啟子進程的兩種方式

方法一:

方法二：

有了join，程序不就是串列了嗎？？？

terminate與is_alive

name與pid

⑷ 關於python多進程使用(Queue、生產者和消費者)

關於 的生產者和消費者的實現，剛好最近有用到，簡單總結記錄下：

是系統獨立調度核分配系統資源（CPU、內存）的基本單位，進程之間是相互獨立的，每啟動一個新的進程相當於把數據進行了一次克隆。
python提供了多種方法實現了多進程中間的 （可以修改同一份數據）。

GIL 的全稱是 Global Interpreter Lock(全局解釋器鎖)，來源是 Python 設計之初的考慮，為了數據安全所做的決定。
某個線程想要執行，必須先拿到 GIL，我們可以把 GIL 看作是「通行證」，並且在一個 Python 進程中，GIL 只有一個，這就導致了多線程搶佔GIL耗時。這就是為什麼在多核CPU上，Python 的多線程效率並不高的根本原因。
所以有必要學習下多進程的使用。

⑸ Python多進程運行——Multiprocessing基礎教程2

上篇文章簡單介紹了multiprocessing模塊，本文將要介紹進程之間的數據共享和信息傳遞的概念。

在多進程處理中，所有新創建的進程都會有這兩個特點：獨立運行，有自己的內存空間。

我們來舉個例子展示一下：

這個程序的輸出結果是：

在上面的程序中我們嘗試在兩個地方列印全局列表result的內容：

我們再用一張圖來幫助理解記憶不同進程間的數據關系：

如果程序需要在不同的進程之間共享一些數據的話，該怎麼做呢？不用擔心，multiprocessing模塊提供了Array對象和Value對象，用來在進程之間共享數據。

所謂Array對象和Value對象分別是指從共享內存中分配的ctypes數組和對象。我們直接來看一個例子，展示如何用Array對象和Value對象在進程之間共享數據：

程序輸出的結果如下：

成功了！主程序和p1進程輸出了同樣的結果，說明程序中確實完成了不同進程間的數據共享。那麼我們來詳細看一下上面的程序做了什麼：

在主程序中我們首先創建了一個Array對象：

向這個對象輸入的第一個參數是數據類型：i表示整數，d代表浮點數。第二個參數是數組的大小，在這個例子中我們創建了包含4個元素的數組。

類似的，我們創建了一個Value對象：

我們只對Value對象輸入了一個參數，那就是數據類型，與上述的方法一致。當然，我們還可以對其指定一個初始值（比如10），就像這樣：

隨後，我們在創建進程對象時，將剛創建好的兩個對象：result和square_sum作為參數輸入給進程：

在函數中result元素通過索引進行數組賦值，square_sum通過 value 屬性進行賦值。

注意：為了完整列印result數組的結果，需要使用 result[:] 進行列印，而square_sum也需要使用 value 屬性進行列印：

每當python程序啟動時，同時也會啟動一個伺服器進程。隨後，只要我們需要生成一個新進程，父進程就會連接到伺服器並請求它派生一個新進程。這個伺服器進程可以保存Python對象，並允許其他進程使用代理來操作它們。

multiprocessing模塊提供了能夠控制伺服器進程的Manager類。所以，Manager類也提供了一種創建可以在不同流程之間共享的數據的方法。

伺服器進程管理器比使用共享內存對象更靈活，因為它們可以支持任意對象類型，如列表、字典、隊列、值、數組等。此外，單個管理器可以由網路上不同計算機上的進程共享。

但是，伺服器進程管理器的速度比使用共享內存要慢。

讓我們來看一個例子：

這個程序的輸出結果是：

我們來理解一下這個程序做了什麼：首先我們創建了一個manager對象

在with語句下的所有行，都是在manager對象的范圍內的。接下來我們使用這個manager對象創建了列表（類似的，我們還可以用 manager.dict() 創建字典）。

最後我們創建了進程p1（用於在records列表中插入一條新的record）和p2（將records列印出來），並將records作為參數進行傳遞。

伺服器進程的概念再次用下圖總結一下：

為了能使多個流程能夠正常工作，常常需要在它們之間進行一些通信，以便能夠劃分工作並匯總最後的結果。multiprocessing模塊支持進程之間的兩種通信通道：Queue和Pipe。

使用隊列來回處理多進程之間的通信是一種比較簡單的方法。任何Python對象都可以使用隊列進行傳遞。我們來看一個例子：

上面這個程序的輸出結果是：

我們來看一下上面這個程序到底做了什麼。首先我們創建了一個Queue對象：

然後，將這個空的Queue對象輸入square_list函數。該函數會將列表中的數平方，再使用 put() 方法放入隊列中：

隨後使用 get() 方法，將q列印出來，直至q重新稱為一個空的Queue對象：

我們還是用一張圖來幫助理解記憶：

一個Pipe對象只能有兩個端點。因此，當進程只需要雙向通信時，它會比Queue對象更好用。

multiprocessing模塊提供了 Pipe() 函數，該函數返回由管道連接的一對連接對象。 Pipe() 返回的兩個連接對象分別表示管道的兩端。每個連接對象都有 send() 和 recv() 方法。

我們來看一個例子：

上面這個程序的輸出結果是：

我們還是來看一下這個程序到底做了什麼。首先創建了一個Pipe對象：

與上文說的一樣，該對象返回了一對管道兩端的兩個連接對象。然後使用 send() 方法和 recv() 方法進行信息的傳遞。就這么簡單。在上面的程序中，我們從一端向另一端發送一串消息。在另一端，我們收到消息，並在收到END消息時退出。

要注意的是，如果兩個進程(或線程)同時嘗試從管道的同一端讀取或寫入管道中的數據，則管道中的數據可能會損壞。不過不同的進程同時使用管道的兩端是沒有問題的。還要注意，Queue對象在進程之間進行了適當的同步，但代價是增加了計算復雜度。因此，Queue對象對於線程和進程是相對安全的。

最後我們還是用一張圖來示意：

Python的multiprocessing模塊還剩最後一篇文章：多進程的同步與池化

敬請期待啦！

⑹ python 多進程

基於官方文檔：
https://docs.python.org/zh-cn/3/library/multiprocessing.html
日樂購，剛才看到的一個博客，寫的都不太對，還是基於官方的比較穩妥
我就是喜歡抄官方的，哈哈

通常我們使用Process實例化一個進程，並調用 他的 start() 方法啟動它。
這種方法和 Thread 是一樣的。

上圖中，我寫了 p.join() 所以主進程是 等待 子進程執行完後，才執行 print("運行結束")
否則就是反過來了（這個不一定，看你的語句了，順序其實是隨機的）例如：

主進加個 sleep

所以不加join() ,其實子進程和主進程是各干各的，誰也不等誰。都執行完後，文件運行就結束了

上面我們用了 os.getpid() 和 os.getppid() 獲取 當前進程，和父進程的id
下面就講一下，這兩個函數的用法：
os.getpid()
返回當前進程的id
os.getppid()
返回父進程的id。 父進程退出後，unix 返回初始化進程（1）中的一個
windows返回相同的id (可能被其他進程使用了)
這也就解釋了，為啥我上面 的程序運行多次， 第一次列印的parentid 都是 14212 了。
而子進程的父級 process id 是調用他的那個進程的 id ： 1940

視頻筆記：
多進程：使用大致方法：

參考： 進程通信（pipe和queue）

pool.map （函數可以有return 也可以共享內存或queue） 結果直接是個列表

poll.apply_async() （同map,只不過是一個進程，返回結果用 xx.get() 獲得）

報錯：

參考 ： https://blog.csdn.net/xiemanR/article/details/71700531

把 pool = Pool() 放到 if name == " main ": 下面初始化搞定。
結果：

這個肯定有解釋的

測試多進程計算效果：
進程池運行：

結果：

普通計算：

我們同樣傳入 1 2 10 三個參數測試：

其實對比下來開始快了一半的；
我們把循環里的數字去掉一個 0；
單進程：

多進程：

兩次測試 單進程/進程池 分別為 0.669 和 0.772 幾乎成正比的。
問題 二：
視圖：
post 視圖裡面

Music 類：

直接報錯：

寫在 類裡面也 在函數里用 self.pool 調用也不行，也是相同的錯誤。

最後 把 pool = Pool 直接寫在 search 函數裡面，奇跡出現了：

前台也能顯示搜索的音樂結果了

總結一點，進程這個東西，最好 寫在 直接運行的函數裡面，而不是 一個函數跳來跳去。因為最後可能 是在子進程的子進程運行的，這是不許的，會報錯。
還有一點，多進程運行的函數對象，不能是 lambda 函數。也許lambda 虛擬，在內存？？

使用 pool.map 子進程 函數報錯，導致整個 pool 掛了:
參考： https://blog.csdn.net/hedongho/article/details/79139606
主要你要，對函數內部捕獲錯誤，而不能讓異常拋出就可以了。

關於map 傳多個函數參數
我一開始，就是正常思維，多個參數，搞個元祖，讓參數一一對應不就行了：

報錯：

參考：
https://blog.csdn.net/qq_15969343/article/details/84672527
普通的 process 當讓可以穿多個參數，map 卻不知道咋傳的。
apply_async 和map 一樣，不知道咋傳的。

最簡單的方法：
使用 starmap 而不是 map

結果：
子進程結束
1.8399453163146973
成功拿到結果了

關於map 和 starmap 不同的地方看源碼：

關於apply_async() ,我沒找到多參數的方法，大不了用 一個迭代的 starmap 實現。哈哈

關於 上面源碼裡面有 itertools.starmap
itertools 用法參考：
https://docs.python.org/zh-cn/3/library/itertools.html#itertool-functions

有個問題，多進程最好不要使用全部的 cpu , 因為這樣可能影響其他任務，所以 在進程池 添加 process 參數 指定，cpu 個數：

上面就是預留了 一個cpu 干其他事的

後面直接使用 Queue 遇到這個問題：

解決：
Manager().Queue() 代替 Queue()

因為 queue.get() 是堵塞型的，所以可以提前判斷是不是 空的，以免堵塞進程。比如下面這樣：
使用 queue.empty() 空為True

⑺ Python入門系列（十二）——GUI+多進程

話說，python做圖形界面並不明智，效率並不高。但在某些特殊需求下還是需要我們去使用，所以python擁有多個第三方庫用以實現GUI，本章我們使用python基本模塊tkinter進行學習，因為需求並不大，所以不做太多拓展。
繼續改寫上一章的IP查詢系統（= =，要玩爛了），首先略改下IpWhere.py以備調用~

然後使用tkinter模塊進行圖形界面的實現，調用預編譯的IpWhere模塊 ：

額，太丑了，但基本實現我們小小的需求，在以後的py學習中，我們再涉及其他的第三方模塊，此處就當是入門了解吧。

十分抱歉把這么重要的內容放在最後，要不是大佬指點，此次學習可能就要錯過多進程的問題了。
Unix系統提供了forx，python可藉助os模塊調用，從而實現多進程，然而windows系統並不具備，所以我們選擇python內置的multiprocessing多進程模塊進行學習。

首先我們藉助直接調用多進程來改寫下我們在多線程章節用到的例子！

顯然，這么寫實在太蠢了，如果我們的任務量巨大，這並不合適。所以我們引入了進程池的概念，使用進程池進行改寫：

在此，我們可以看到所有進程是並發執行的，同樣，我們在多線程章節就講過，主進程的結束意味著程序退出，所以我們需要藉助join()方法堵塞進程。

我們知道線程共享內存空間，而進程的內存是獨立的，同一個進程的線程之間可以直接交流，也就帶來了線程同步的苦惱，這個我們在多線程章節已經講過了；而兩個進程想通信，則必須通過一個中間代理來實現，即我們接下來的內容：進程間通信。

進程之間肯定是需要通信的，操作系統提供了很多機制來實現進程間的通信。Python的multiprocessing模塊包裝了底層的機制，提供了Queue、Pipes等多種方式來交換數據。我們接下來就以Queue的方式進行學習。

Queue.Queue是進程內非阻塞隊列，multiprocess.Queue是跨進程通信隊列，前者是各自私有，後者是各子進程共有。

還有一個在後者基礎上進行封裝的multiprocess.Manager.Queue()方法，如果要使用Pool創建進程，就需要使用multiprocessing.Manager()中的Queue()，而不是multiprocessing.Queue()，否則會得到一條如下的錯誤信息： RuntimeError: Queue objects should only be shared between processes through inheritance.

接下來我們就藉助進程池來進行多進程操作的改寫，感謝大佬一路輔導。

我們可以看到兩個子線程先執行，然後一個子線程單獨執行，此處有意而為之，讓大家更清晰的了解隊列的使用。期間有一處我們放棄使用jion()方法堵塞，而是自己寫了個循環堵塞，大家根據自己習慣來就好。

話說，真的沒人吐槽么？上面的例子從需求上來講，完全就不需要多線程好不好！emmmm，我們來點實力拓展，寫一個有智商的多線程腳本，順便結合上一節的web來一個綜合篇，隨便找個現實需求吧！

emmm，比如我們來到當當網買書，搜一下我們想要的書籍，發現！！太多了！！真J2亂！！看不過來！！不想翻頁！！直接告訴我哪個便宜、哪個牛逼好不好！！

簡單看下這個url：
http://search.dangdang.com/?key=滲透測試&ddsale=1&page_index=2
其中ddsale參數代表當當自營，page_index代表頁數，key代表搜索內容，我們本次的變數只有頁數。

所以我們構造請求的url為:
'http://search.dangdang.com/?key=滲透測試&ddsale=1&page_index='+str(page)
如果修改的內容不使用str字元串轉化，會收到如下報錯：
TypeError: can only concatenate str (not "int") to str
然後我們看一下頁面內容的分布情況，本次我們關心賣什麼書，賣多少錢？

對應的編寫我們的正則匹配規則，當然了，有更簡便的第三方庫可以幫我們處理，但為了更好的形成流程性認識，我們這里依然使用正則。
我們對應我們需要的書籍名稱和當前價格匹配如下：
<a title=" (.*?)" ddclick=
<span class="search_now_price">¥(.*?)</span>
那麼，思路理清了，我們就開始使用多線程來寫我們的小系統~

然後我們去查看一下我們的結果文件~

現在這個小系統具備的功能就是根據用戶需要選擇要檢索的書籍，然後整理下名稱和價格，開了10個線程，如果小夥伴pc給力的話可以繼續加。簡單的異常處理機制和界面交互，基本滿足日常所需。

⑻ Python的多進程模塊multiprocessing

眾所周知，Python中不存在真正的多線程，Python中的多線程是一個並發過程。如果想要並行的執行程序，充分的利用cpu資源(cpu核心)，還是需要使用多進程解決的。其中multiprocessing模塊應該是Python中最常用的多進程模塊了。

基本上multiprocessing這個模塊和threading這個模塊用法是相同的，也是可以通過函數和類創建進程。

上述案例基本上就是筆者搬用了上篇文章多線程的案例，可見其使用的相似之處。導入multiprocessing後實例化Process就可以創建一個進程，參數的話也是和多線程一樣，target放置進程執行函數，args存放該函數的參數。

使用類來創建進程也是需要先繼承multiprocessing.Process並且實現其init方法。

Pool可以提供指定數量的進程，供用戶調用，當有新的請求提交到pool中時，如果池還沒有滿，那麼就會創建一個新的進程用來執行該請求。

但如果池中的進程數已經達到規定最大值，那麼該請求就會等待，直到池中有進程結束，才會創建新的進程。

需要注意的是，在調用join方法阻塞進程前，需要先調用close方法，，否則程序會出錯。

在上述案例中，提到了非阻塞，當把創建進程的方法換為pool.apply(func, (msg,))時，就會阻塞進程，出現下面的狀況。

在multiprocessing模塊中還存在Queue對象，這是一個進程的安全隊列，近似queue.Queue。隊列一般也是需要配合多線程或者多進程使用。

下列案例是一個使用進程隊列實現的生產者消費者模式。

multiprocessing支持兩種進程間的通信，其中一種便是上述案例的隊列，另一種則稱作管道。在官方文檔的描述中，multiprocessing中的隊列是基於管道實現的，並且擁有更高的讀寫效率。

管道可以理解為進程間的通道，使用Pipe([plex])創建，並返回一個元組(conn1,conn2)。如果plex被置為True(默認值)，那麼該管道是雙向的，如果plex被置為False，那麼該管道是單向的，即conn1隻能用於接收消息，而conn2僅能用於發送消息。

其中conn1、conn2表示管道兩端的連接對象，每個連接對象都有send()和recv()方法。send和recv方法分別是發送和接受消息的方法。例如，可以調用conn1.send發送消息，conn1.recv接收消息。如果沒有消息可接收，recv方法會一直阻塞。如果管道已經被關閉，那麼recv方法會拋出EOFError。

關於multiprocessing模塊其實還有很多實用的類和方法，由於篇幅有限(懶),筆者就先寫到這里。該模塊其實用起來很像threading模塊，像鎖對象和守護線程(進程)等multiprocessing模塊也是有的，使用方法也近乎相同。

如果想要更加詳細的了解multiprocessing模塊，請參考官方文檔。

⑼ python 在類里使用進程池

由於第1點 不合理， 所以有什麼辦法在類 函數中獲取 進程池對象po的地址：

我的解決思路和方法是:

ps : (圖沒截好 ， rglob_worker 是外部函數 ， 非類內函數 ，po = getPoolBojcet() 這一行是類內函數 ，紅色箭頭 2. 在的那條白色分割線 是2個函數。 )

len(po._cache) == 1 : po._cache 是當前有任務的進程數， ==1表示所有任務結束;

利用回調 ， 可以更輕松地進行進程通信。

⑽ Linux平台下python中有什麼方法可以與一個進程通信

本文實例講解了python實現兩個程序之間通信的方法，具體方法如下：
該實例採用socket實現，與socket網路編程不一樣的是socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)的第一個參數是socket.AF_UNIX
而不是 socket.AF_INET
例中兩個python程序 s.py/c.py 要先運行s.py
基於fedora13/python2.6測試，成功實現！
s.py代碼如下：
#!/usr/bin/env python
import socket
import os

if __name__ == '__main__':
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
conn = '/tmp/conn'
if not os.path.exists(conn):
os.mknod(conn)
if os.path.exists(conn):
os.unlink(conn)
sock.bind(conn)
sock.listen(5)
while True:
connection,address = sock.accept()
data = connection.recv(1024)
if data == "hello,server":
print "the client said:%s!\n" % data
connection.send("hello,client")
connection.close()

c.py代碼如下：
#!/usr/bin/env python
import socket
import time

if __name__ == '__main__':
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
conn = '/tmp/conn'
sock.connect(conn)
time.sleep(1)
sock.send('hello,server')
print sock.recv(1024)
sock.close()