進程間通信

進程彼此之間互相隔離，要實現進程間通信（IPC），multiprocessing模塊支持兩種形式：隊列和管道，這兩種方式都是使用消息傳遞的。

進程隊列queue

不同于線程queue，進程queue的生成是用multiprocessing模塊生成的。

在生成子進程的時候，會將代碼拷貝到子進程中執行一遍，及子進程擁有和主進程內容一樣的不同的名稱空間。

示例1：

1 import multiprocessing2 def foo():3 q.put([11,'hello',True])4 print(q.qsize())5 6 q=multiprocessing.Queue() #全局定義一個q進程隊列，在產生子進程時候會在子進程里生成，可以指定最大數，限制隊列長度7 if __name__ == '__main__':8 p=multiprocessing.Process(target=foo,args=()) #因為名稱空間不同，子進程的主線程創建的q隊列，主進程get不到，所以會阻塞住9 p.start() 10 # foo() #主進程執行一下函數就可以訪問到了 11 print(q.get())

?

示例2：

1 import multiprocessing2 3 def foo():4 q.put([11,'hello',True])5 print(q.qsize())6 7 if __name__ == '__main__':8 q = multiprocessing.Queue() #主進程創建一個q進程隊列9 p=multiprocessing.Process(target=foo,args=()) #因為名稱空間不同，子進程的主線程找不到q隊列，所以會報錯提示沒有q 10 p.start() 11 print(q.get())

?

示例3：

1 import multiprocessing2 3 def foo(argument): #定義函數處理進程隊列4 argument.put([11,'hello',True])5 print(argument.qsize())6 q = multiprocessing.Queue() #全局定義一個進程隊列7 print('test')8 9 if __name__ == '__main__': 10 x = multiprocessing.Queue() #主進程定義一個進程隊列 11 p=multiprocessing.Process(target=foo,args=(x,)) #主進程把值傳給子進程就可以處理了 12 p.start() 13 print(x.get()) 14 # foo(q) 15 # print(q.get())

?

常用方法

q.put方法用以插入數據到隊列中，put方法還有兩個可選參數：blocked和timeout。如果blocked為True（默認值），并且timeout為正值，該方法會阻塞timeout指定的時間，直到該隊列有剩余的空間。如果超時，會拋出Queue.Full異常。如果blocked為False，但該Queue已滿，會立即拋出Queue.Full異常。 q.get方法可以從隊列讀取并且刪除一個元素。同樣，get方法有兩個可選參數：blocked和timeout。如果blocked為True（默認值），并且timeout為正值，那么在等待時間內沒有取到任何元素，會拋出Queue.Empty異常。如果blocked為False，有兩種情況存在，如果Queue有一個值可用，則立即返回該值，否則，如果隊列為空，則立即拋出Queue.Empty異常. q.get_nowait():同q.get(False) q.put_nowait():同q.put(False) q.empty():調用此方法時q為空則返回True，該結果不可靠，比如在返回True的過程中，如果隊列中又加入了項目。 q.full()：調用此方法時q已滿則返回True，該結果不可靠，比如在返回True的過程中，如果隊列中的項目被取走。 q.qsize():返回隊列中目前項目的正確數量，結果也不可靠，理由同q.empty()和q.full()一樣

?

其他方法

q.cancel_join_thread():不會在進程退出時自動連接后臺線程。可以防止join_thread()方法阻塞 q.close():關閉隊列，防止隊列中加入更多數據。調用此方法，后臺線程將繼續寫入那些已經入隊列但尚未寫入的數據，但將在此方法完成時馬上關閉。如果q被垃圾收集，將調用此方法。關閉隊列不會在隊列使用者中產生任何類型的數據結束信號或異常。例如，如果某個使用者正在被阻塞在get()操作上，關閉生產者中的隊列不會導致get()方法返回錯誤。 q.join_thread()：連接隊列的后臺線程。此方法用于在調用q.close()方法之后，等待所有隊列項被消耗。默認情況下，此方法由不是q的原始創建者的所有進程調用。調用q.cancel_join_thread方法可以禁止這種行為

?

另一個創建進程隊列的類

http://www.cnblogs.com/zero527/p/7211909.html

管道pipe

管道就是管道，就像生活中的管道，兩頭都能進能出

默認管道是全雙工的，如果創建管道的時候映射成False，左邊只能用于接收，右邊只能用于發送，類似于單行道

最簡單的管道雙向通信示例：

1 import multiprocessing2 3 def foo(sk):4 sk.send('hello world')5 print(sk.recv())6 7 if __name__ == '__main__':8 conn1,conn2=multiprocessing.Pipe() #開辟兩個口，都是能進能出，括號中如果False即單向通信9 p=multiprocessing.Process(target=foo,args=(conn1,)) #子進程使用sock口，調用foo函數 10 p.start() 11 print(conn2.recv()) #主進程使用conn口接收 12 conn2.send('hi son') #主進程使用conn口發送

?

常用方法

conn1.recv():接收conn2.send(obj)發送的對象。如果沒有消息可接收，recv方法會一直阻塞。如果連接的另外一端已經關閉，那么recv方法會拋出EOFError。 conn1.send(obj):通過連接發送對象。obj是與序列化兼容的任意對象
注意：send()和recv()方法使用pickle模塊對對象進行序列化

?

其他方法

conn1.close():關閉連接。如果conn1被垃圾回收，將自動調用此方法,不用的時候兩邊都要closeconn1.fileno():返回連接使用的整數文件描述符conn1.poll([timeout]):如果連接上的數據可用，返回True。timeout指定等待的最長時限。如果省略此參數，方法將立即返回結果。如果將timeout射成None，操作將無限期地等待數據到達。conn1.recv_bytes([maxlength]):接收c.send_bytes()方法發送的一條完整的字節消息。maxlength指定要接收的最大字節數。如果進入的消息，超過了這個最大值，將引發IOError異常，并且在連接上無法進行進一步讀取。如果連接的另外一端已經關閉，再也不存在任何數據，將引發EOFError異常。conn.send_bytes(buffer [, offset [, size]])：通過連接發送字節數據緩沖區，buffer是支持緩沖區接口的任意對象，offset是緩沖區中的字節偏移量，而size是要發送字節數。結果數據以單條消息的形式發出，然后調用c.recv_bytes()函數進行接收 conn1.recv_bytes_into(buffer [, offset]):接收一條完整的字節消息，并把它保存在buffer對象中，該對象支持可寫入的緩沖區接口（即bytearray對象或類似的對象）。offset指定緩沖區中放置消息處的字節位移。返回值是收到的字節數。如果消息長度大于可用的緩沖區空間，將引發BufferTooShort異常。

?

注意：生產者和消費者都沒有使用管道的某個端點，就應該將其關閉，如在生產者中關閉管道的右端，在消費者中關閉管道的左端。如果忘記執行這些步驟，程序可能再消費者中的recv()操作上掛起。管道是由操作系統進行引用計數的,必須在所有進程中關閉管道后才能生產EOFError異常。因此在生產者中關閉管道不會有任何效果，付費消費者中也關閉了相同的管道端點。

1 from multiprocessing import Process,Pipe2 3 import time,os4 def consumer(p,name):5 left,right=p6 left.close()7 while True:8 try:9 baozi=right.recv() 10 print('%s 收到包子:%s' %(name,baozi)) 11 except EOFError: 12 right.close() 13 break 14 def producer(seq,p): 15 left,right=p 16 right.close() 17 for i in seq: 18 left.send(i) 19 # time.sleep(1) 20 else: 21 left.close() 22 if __name__ == '__main__': 23 left,right=Pipe() 24 c1=Process(target=consumer,args=((left,right),'c1')) 25 c1.start() 26 seq=(i for i in range(10)) 27 producer(seq,(left,right)) 28 right.close() 29 left.close() 30 c1.join() 31 print('主進程')
1 from multiprocessing import Process,Pipe2 3 import time,os4 def consumer(p,name):5 left,right=p6 left.close()7 while True:8 try:9 baozi=right.recv() 10 print('%s 收到包子:%s' %(name,baozi)) 11 except EOFError: 12 right.close() 13 break 14 def producer(seq,p): 15 left,right=p 16 right.close() 17 for i in seq: 18 left.send(i) 19 # time.sleep(1) 20 else: 21 left.close() 22 if __name__ == '__main__': 23 left,right=Pipe() 24 c1=Process(target=consumer,args=((left,right),'c1')) 25 c1.start() 26 seq=(i for i in range(10)) 27 producer(seq,(left,right)) 28 right.close() 29 left.close() 30 c1.join() 31 print('主進程')

?

?

共享數據manage

Queue和pipe只是實現了數據交互，并沒實現數據共享，即一個進程去更改另一個進程的數據。

注：進程間通信應該盡量避免使用共享數據的方式

?

共享數據：列表

1 from multiprocessing import Manager,Process2 def foo(l,i):3 l.append(i**i)4 if __name__ == '__main__':5 man=Manager()6 ml=man.list([11,22,33])7 l=[]8 for i in range(5):9 p=Process(target=foo,args=(ml,i)) 10 p.start() 11 l.append(p) 12 for i in l: #必須要join，不然會執行報錯，處理一個數據必須要一個個來，不能同時處理一個數據 13 i.join() 14 print(ml)

?

共享數據：字典

1 from multiprocessing import Manager,Process2 def foo(d,k,v):3 d[k]=v4 if __name__ == '__main__':5 man=Manager()6 md=man.dict({'name':'bob'})7 l=[]8 for i in range(5):9 p=Process(target=foo,args=(md,i,'a')) 10 p.start() 11 l.append(p) 12 for i in l: #必須要join，不然會執行報錯，處理一個數據必須要一個個來，不能同時處理一個數據 13 i.join() 14 print(md)

?

?

進程池

開多進程是為了并發，通常有幾個cpu核心就開幾個進程，但是進程開多了會影響效率，主要體現在切換的開銷，所以引入進程池限制進程的數量。

進程池內部維護一個進程序列，當使用時，則去進程池中獲取一個進程，如果進程池序列中沒有可供使用的進進程，那么程序就會等待，直到進程池中有可用進程為止。

示例：

1 from multiprocessing import Pool2 import time3 4 def foo(n):5 print(n)6 time.sleep(1)7 8 if __name__ == '__main__':9 pool_obj=Pool(5) # 10 for i in range(47): 11 # pool_obj.apply_async(func=foo,args=(i,)) 12 pool_obj.apply(func=foo,args=(i,)) #子進程的生成是靠進程池對象維護的 13 # apply同步，子進程一個個執行 14 # apply_async異步，多個子進程一起執行 15 pool_obj.close() 16 pool_obj.join() 17 print('ending')

?

常用方法：

pool_obj.apply(func [, args [, kwargs]]):在一個池工作進程中執行func(*args,**kwargs),然后返回結果。需要強調的是：此操作并不會在所有池工作進程中并執行func函數。如果要通過不同參數并發地執行func函數，必須從不同線程調用p.apply()函數或者使用p.apply_async() pool_obj.apply_async(func [, args [, kwargs]]):在一個池工作進程中執行func(*args,**kwargs),然后返回結果。此方法的結果是AsyncResult類的實例，callback是可調用對象，接收輸入參數。當func的結果變為可用時，將理解傳遞給callback。callback禁止執行任何阻塞操作，否則將接收其他異步操作中的結果。 pool_obj.close():關閉進程池，防止進一步操作。如果所有操作持續掛起，它們將在工作進程終止前完成 pool_obj.jion():等待所有工作進程退出。此方法只能在close（）或teminate()之后調用

?

其他方法：

方法apply_async()和map_async（）的返回值是AsyncResul的實例obj。實例具有以下方法 obj.get():返回結果，如果有必要則等待結果到達。timeout是可選的。如果在指定時間內還沒有到達，將引發一場。如果遠程操作中引發了異常，它將在調用此方法時再次被引發。 obj.ready():如果調用完成，返回True obj.successful():如果調用完成且沒有引發異常，返回True，如果在結果就緒之前調用此方法，引發異常 obj.wait([timeout]):等待結果變為可用。 obj.terminate()：立即終止所有工作進程，同時不執行任何清理或結束任何掛起工作。如果p被垃圾回收，將自動調用此函數

?

?

協程

協程：是單線程下的并發，又稱微線程，纖程。英文名Coroutine。

一句話說明什么是線程：協程是一種用戶態的輕量級線程，即協程是由用戶程序自己控制調度的。

協程能保留上一次調用時的狀態（即所有局部狀態的一個特定組合），每次過程重入時，就相當于進入上一次調用的狀態，換種說法：進入上一次離開時所處邏輯流的位置。

注意：

　　1. python的線程屬于內核級別的，即由操作系統控制調度（如單線程一旦遇到io就被迫交出cpu執行權限，切換其他線程運行）

　　2. 單線程內開啟協程，一旦遇到io，從應用程序級別（而非操作系統）控制切換

協程優點：

　　1. ?協程的切換開銷更小，屬于程序級別的切換，操作系統完全感知不到，因而更加輕量級

　　2. 單線程內就可以實現并發的效果，最大限度地利用cpu

協程缺點：

　　1.協程的本質是單線程下，無法利用多核，可以是一個程序開啟多個進程，每個進程內開啟多個線程，每個線程內開啟協程

　　2.協程指的是單個線程，因而一旦協程出現阻塞，將會阻塞整個線程

yield實現協程并發

1 import time2 def consumer():3 r=''4 while True:5 n=yield r6 if not n:7 return8 print('[CONSUMER] ←← Consuming %s...' % n)9 time.sleep(1) 10 r='200 Ok' 11 12 def produce(c): 13 next(c) #1.啟動生成器 14 n=0 15 while n < 5: 16 n=n+1 17 print('[PRODUCER] →→ Producing %s...' % n) 18 cr=c.send(n) 19 #2.將n傳入到consumer的對象，yield接收到傳入值開始執行代碼，遇到yield執行代碼返回r的值 20 print('[PRODUCER] Consumer return: %s' % cr) 21 #3.produce沒有值了，關閉整個過程 22 c.close() 23 24 if __name__ == '__main__': 25 c=consumer() #生成生成器對象 26 produce(c) #執行調用

?

?

greenlet框架實現協程（封裝yield的基礎庫）

greenlet機制的主要思想是：生成器函數或者協程函數中的yield語句掛起函數的執行，直到稍后使用next()或send()操作進行恢復為止。可以使用一個調度器循環在一組生成器函數之間協作多個任務。greentlet是python中實現我們所謂的"Coroutine(協程)"的一個基礎庫。

示例1：

1 from greenlet import greenlet2 def foo():3 print('ok1')4 g2.switch() #阻斷5 print('ok3')6 g2.switch()7 def bar():8 print('ok2')9 g1.switch() 10 print('ok4') 11 12 g1=greenlet(foo) #生成foo函數的greenlet對象 13 g2=greenlet(bar) #生成bar函數的greenlet對象 14 g1.switch() #1、執行g1對象，打印ok1 15 #2、遇到g2.switch()，轉到g2執行打印ok2 16 #3、遇到g1.switch(),轉到g1的阻斷處繼續執行打印ok3 17 #4、遇到g2.switch()，轉到g2執行打印ok4

?

示例2：

1 def eat(name):2 print('%s eat food 1' %name)3 gr2.switch('bob')4 print('%s eat food 2' %name)5 gr2.switch()6 def play_phone(name):7 print('%s play 1' %name)8 gr1.switch()9 print('%s play 2' %name) 10 11 gr1=greenlet(eat) 12 gr2=greenlet(play_phone) 13 gr1.switch(name='natasha')#可以在第一次switch時傳入參數，以后都不需要

?

這種方法不會節省時間，因為不是io操作，而greenlet遇到io操作不會跳轉，仍然要io阻斷

?

基于greenlet框架的高級庫gevent模塊

gevent是第三方庫，通過greenlet實現協程，其基本思想是：

當一個greenlet遇到IO操作時，比如訪問網絡，就自動切換到其他的greenlet，等到IO操作完成，再在適當的時候切換回來繼續執行。由于IO操作非常耗時，經常使程序處于等待狀態，有了gevent為我們自動切換協程，就保證總有greenlet在運行，而不是等待IO。

由于切換是在IO操作時自動完成，所以gevent需要修改Python自帶的一些標準庫，這一過程在啟動時通過monkey patch完成：

簡單示例：

1 import gevent2 def foo():3 print('ok1')4 gevent.sleep(4) #模擬io操作5 print('ok3')6 def bar():7 print('ok2')8 gevent.sleep(2)9 print('ok4') 10 11 g1=gevent.spawn(foo) 12 g2=gevent.spawn(bar) 13 gevent.joinall([g1,g2]) #全部阻塞，或者單獨一個個join

?

spawn括號內第一個參數是函數名，如foo，后面可以有多個參數，可以是位置實參或關鍵字實參，都是傳給函數foo的

注意：

gevent.sleep(4)模擬的是gevent可以識別的io阻塞,

而time.sleep(2)或其他的阻塞,gevent是不能直接識別的需要用下面一行代碼,打補丁,就可以識別了

1 #補丁 2 from gevent import monkey 3 monkey.patch_all()

?

必須放到被打補丁者的前面，如time，socket模塊之前

或者我們干脆記憶成：要用gevent，需要將補丁放到文件的開頭

爬蟲示例：

1 from gevent import monkey;monkey.patch_all()2 import gevent3 import requests4 import time5 6 def get_page(url):7 print('GET: %s' %url)8 response=requests.get(url)9 if response.status_code == 200: 10 print('%d bytes received from %s' %(len(response.text),url)) 11 12 13 start_time=time.time() 14 gevent.joinall([ 15 gevent.spawn(get_page,'https://www.python.org/'), 16 gevent.spawn(get_page,'https://www.yahoo.com/'), 17 gevent.spawn(get_page,'https://github.com/'), 18 ]) 19 stop_time=time.time() 20 print('run time is %s' %(stop_time-start_time))

?

gevent是一個基于協程（coroutine）的Python網絡函數庫，通過使用greenlet提供了一個在libev事件循環頂部的高級別并發API。主要特性有以下幾點：<1> 基于libev的快速事件循環，Linux上面的是epoll機制<2> 基于greenlet的輕量級執行單元<3> API復用了Python標準庫里的內容<4> 支持SSL的協作式sockets<5> 可通過線程池或c-ares實現DNS查詢<6> 通過monkey patching功能來使得第三方模塊變成協作式gevent.spawn()方法spawn一些jobs，然后通過gevent.joinall將jobs加入到微線程執行隊列中等待其完成，設置超時為2秒。執行后的結果通過檢查gevent.Greenlet.value值來收集。＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝二 1、關于Linux的epoll機制：epoll是Linux內核為處理大批量文件描述符而作了改進的poll，是Linux下多路復用IO接口select/poll的 增強版本，它能顯著提高程序在大量并發連接中只有少量活躍的情況下的系統CPU利用率。epoll的優點：（1）支持一個進程打開大數目的socket描述符。select的一個進程所打開的FD由FD_SETSIZE的設置來限定，而epoll沒有這個限制，它所支持的FD上限是 最大可打開文件的數目，遠大于2048。（2）IO效率不隨FD數目增加而線性下降：由于epoll只會對“活躍”的socket進行操作，于是，只有”活躍”的socket才會主動去調用 callback函數，其他 idle狀態的socket則不會。（3）使用mmap加速內核與用戶空間的消息傳遞。epoll是通過內核于用戶空間mmap同一塊內存實現的。（4）內核微調。2、libev機制提供了指定文件描述符事件發生時調用回調函數的機制。libev是一個事件循環器：向libev注冊感興趣的事件，比如socket可讀事件，libev會對所注冊的事件 的源進行管理，并在事件發生時觸發相應的程序。＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝三‘’‘import geventfrom gevent import socketurls = [‘www.google.com.hk’,’www.example.com’, ‘www.python.org’ ]jobs = [gevent.spawn(socket.gethostbyname, url) for url in urls]gevent.joinall(jobs, timeout=2)[job.value for job in jobs][‘74.125.128.199’, ‘208.77.188.166’, ‘82.94.164.162’]’‘’gevent.spawn()方法spawn一些jobs，然后通過gevent.joinall將jobs加入到微線程執行隊列中等待其完成，設置超時為2秒。執行后的結果通過檢查gevent.Greenlet.value值來收集。gevent.socket.gethostbyname()函數與標準的socket.gethotbyname()有相同的接口，但它不會阻塞整個解釋器，因此會使得其他的greenlets跟隨著無阻的請求而執行。Monket patchingPython的運行環境允許我們在運行時修改大部分的對象，包括模塊、類甚至函數。雖然這樣做會產生“隱式的副作用”，而且出現問題很難調試，但在需要修改Python本身的基礎行為時，Monkey patching就派上用場了。Monkey patching能夠使得gevent修改標準庫里面大部分的阻塞式系統調用，包括socket,ssl,threading和select等模塊，而變成協作式運行。from gevent import monkey ;monkey . patch_socket ()import urllib2通過monkey.patch_socket()方法，urllib2模塊可以使用在多微線程環境，達到與gevent共同工作的目的。事件循環不像其他網絡庫，gevent和eventlet類似， 在一個greenlet中隱式開始事件循環。沒有必須調用run()或dispatch()的反應器(reactor)，在twisted中是有 reactor的。當gevent的API函數想阻塞時，它獲得Hub實例(執行時間循環的greenlet),并切換過去。如果沒有集線器實例則會動態 創建。libev提供的事件循環默認使用系統最快輪詢機制，設置LIBEV_FLAGS環境變量可指定輪詢機制。LIBEV_FLAGS=1為select， LIBEV_FLAGS = 2為poll， LIBEV_FLAGS = 4為epoll,LIBEV_FLAGS = 8為kqueue。Libev的API位于gevent.core下。注意libev API的回調在Hub的greenlet運行，因此使用同步greenlet的API。可以使用spawn()和Event.set()等異步API。

?

轉載于:https://www.cnblogs.com/chenqizhou/p/7359689.html

總結

以上是生活随笔為你收集整理的Python开发基础--- 进程间通信、进程池、协程的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。