Python學習筆記18：標準庫之多進程（multiprocessing包）

標籤：intern   看到了   bsp   max   不同   time   async   整數   筆記   

我們能夠使用subprocess包來建立子進程。但這個包有兩個非常大的局限性：
1) 我們總是讓subprocess執行外部的程式，而不是執行一個Python指令碼內部編寫的函數。
2) 進程間僅僅通過管道進行文本交流。
以上限制了我們將subprocess包應用到更廣泛的多進程任務。
這種比較實際是不公平的，由於subprocessing本身就是設計成為一個shell，而不是一個多流程管理組件。

一 threading和multiprocessingmultiprocessing包是Python中的多流程管理組件。
與threading.Thread類似。它能夠利用multiprocessing.Process對象來建立一個進程。
該進程能夠執行在Python程式內部編寫的函數。
該Process對象與Thread對象的使用方法同樣，也有start(), run(), join()的方法。
此外multiprocessing包中也有Lock/Event/Semaphore/Condition類 (這些對象能夠像多線程那樣，通過參數傳遞給各個進程)，用以同步進程。其使用方法與threading包中的同名類一致。
所以。multiprocessing的非常大一部份與threading使用同一套API，僅僅只是換到了多進程的情境。

但在使用這些共用API的時候，我們要注意下面幾點:
1）在UNIX平台上，當某個進程終結之後。該進程須要被其父進程調用wait，否則進程成為殭屍進程(Zombie)。

所以。有必要對每一個Process對象調用join()方法 (實際上等同於wait)。對於多線程來說，因為僅僅有一個進程。所以不存在此必要性。
2）multiprocessing提供了threading包中沒有的IPC(比方Pipe和Queue)，效率上更高。

應優先考慮Pipe和Queue，避免使用Lock/Event/Semaphore/Condition等同步方式 (由於它們佔領的不是使用者進程的資源)。
3）多進程應該避免共用資源。

在多線程中，我們能夠比較easy地共用資源，比方使用全域變數或者傳遞參數。
在多進程情況下。因為每一個進程有自己獨立的記憶體空間。以上方法並不合適。此時我們能夠通過共用記憶體和Manager的方法來共用資源。
但這樣做提高了程式的複雜度，並由於同步的須要而減少了程式的效率。Process.PID中儲存有PID，假設進程還沒有start()。則PID為None。

我們能夠從以下的程式中看到Thread對象和Process對象在使用上的相似性與結果上的不同。各個線程和進程都做一件事：列印PID。
但問題是，全部的任務在列印的時候都會向同一個標準輸出(stdout)輸出。這樣輸出的字元會混合在一起，無法閱讀。
使用Lock同步，在一個任務輸出完畢之後，再同意還有一個任務輸出，能夠避免多個任務同一時候向終端輸出。

# Similarity and difference of multi thread vs. multi process import osimport threadingimport multiprocessing # worker functiondef worker(sign, lock):    lock.acquire()    print(sign, os.getpid())    lock.release() # Mainprint(‘Main:‘,os.getpid()) # Multi-threadrecord = []lock  = threading.Lock()for i in range(5):    thread = threading.Thread(target=worker,args=(‘thread‘,lock))    thread.start()    record.append(thread) for thread in record:    thread.join() # Multi-processrecord = []lock = multiprocessing.Lock()for i in range(5):    process = multiprocessing.Process(target=worker,args=(‘process‘,lock))    process.start()    record.append(process) for process in record:    process.join()

全部Thread的PID都與主程式同樣，而每一個Process都有一個不同的PID。

二 Pipe和Queue管道PIPE和訊息佇列message queue，multiprocessing包中有Pipe類和Queue類來分別支援這兩種IPC機制。Pipe和Queue能夠用來傳送常見的對象。


1) Pipe能夠是單向(half-duplex)。也能夠是雙向(duplex)。

我們通過mutiprocessing.Pipe(duplex=False)建立單向管道 (默覺得雙向)。
一個進程從PIPE一端輸入對象，然後被PIPE還有一端的進程接收，單向管道僅僅同意管道一端的進程輸入，而雙向管道則同意從兩端輸入。

以下的程式展示了Pipe的使用:

# Multiprocessing with Pipe import multiprocessing as mul def proc1(pipe):    pipe.send(‘hello‘)    print(‘proc1 rec:‘,pipe.recv()) def proc2(pipe):    print(‘proc2 rec:‘,pipe.recv())    pipe.send(‘hello, too‘) # Build a pipepipe = mul.Pipe() # Pass an end of the pipe to process 1p1   = mul.Process(target=proc1, args=(pipe[0],))# Pass the other end of the pipe to process 2p2   = mul.Process(target=proc2, args=(pipe[1],))p1.start()p2.start()p1.join()p2.join()

這裡的Pipe是雙向的。
Pipe對象建立的時候，返回一個含有兩個元素的表。每一個元素代表Pipe的一端(Connection對象)。
我們對Pipe的某一端調用send()方法來傳送對象，在還有一端使用recv()來接收。


2) Queue與Pipe相類似，都是先進先出的結構。但Queue同意多個進程放入，多個進程從隊列取出對象。
Queue使用mutiprocessing.Queue(maxsize)建立。maxsize表示隊列中能夠存放對象的最大數量。
以下的程式展示了Queue的使用:

import osimport multiprocessingimport time#==================# input workerdef inputQ(queue):    info = str(os.getpid()) + ‘(put):‘ + str(time.time())    queue.put(info) # output workerdef outputQ(queue,lock):    info = queue.get()    lock.acquire()    print (str(os.getpid()) + ‘(get):‘ + info)    lock.release()#===================# Mainrecord1 = []   # store input processesrecord2 = []   # store output processeslock  = multiprocessing.Lock()    # To prevent messy printqueue = multiprocessing.Queue(3) # input processesfor i in range(10):    process = multiprocessing.Process(target=inputQ,args=(queue,))    process.start()    record1.append(process) # output processesfor i in range(10):    process = multiprocessing.Process(target=outputQ,args=(queue,lock))    process.start()    record2.append(process) for p in record1:    p.join() queue.close()  # No more object will come, close the queue for p in record2:    p.join()

一些進程使用put()在Queue中放入字串，這個字串中包括PID和時間。
還有一些進程從Queue中取出，並列印自己的PID以及get()的字串。


三 進程池進程池 (Process Pool)能夠建立多個進程。這些進程就像是隨時待命計程車兵，準備運行任務(程式)。

一個進程池中能夠容納多個待命計程車兵。

比方以下的程式:

import multiprocessing as mul def f(x):    return x**2 pool = mul.Pool(5)rel  = pool.map(f,[1,2,3,4,5,6,7,8,9,10])print(rel)

我們建立了一個容許5個進程的進程池 (Process Pool) 。Pool執行的每一個進程都執行f()函數。
我們利用map()方法，將f()函數作用到表的每一個元素上。這與built-in的map()函數類似。僅僅是這裡用5個進程平行處理。
假設進程執行結束後，還有須要處理的元素。那麼的進程會被用於又一次執行f()函數。除了map()方法外。Pool還有以下的經常用法。

1）apply_async(func,args)從進程池中取出一個進程運行func。args為func的參數。
它將返回一個AsyncResult的對象。你能夠對該對象調用get()方法以獲得結果。

2）close()進程池不再建立新的進程
3）join()wait進程池中的所有進程。

必須對Pool先調用close()方法才幹join。

四 共用資源多進程共用資源必定會帶來進程間相互競爭。而這樣的競爭又會造成race condition，我們的結果有可能被競爭的不確定性所影響。
但假設須要，我們依舊能夠通過共用記憶體和Manager對象這麼做。


1 共用記憶體依據共用記憶體(shared memory)的原理，這裡給出用Python實現的範例:

import multiprocessing def f(n, a):    n.value   = 3.14    a[0]      = 5 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.valueprint arr[:]

這裡我們實際上僅僅有主進程和Process對象代表的進程。
我們在主進程的記憶體空間中建立共用的記憶體，也就是Value和Array兩個對象。對象Value被設定成為雙精確度數(d), 並初始化為0.0。
而Array則類似於C中的數組，有固定的類型(i, 也就是整數)。在Process進程中，我們改動了Value和Array對象。
回到主程式。列印出結果，主程式也看到了兩個對象的改變，說明資源確實在兩個進程之間共用。

 

2 ManagerManager對象類似於伺服器與客戶之間的通訊 (server-client)，與我們在Internet上的活動非常類似。

我們用一個進程作為server，建立Manager來真正存放資源。其他的進程能夠通過參數傳遞或者依據地址來訪問Manager，建立串連後。操作server上的資源。

在防火牆同意的情況下，我們全然能夠將Manager運用於多電腦。從而模仿了一個真實的網路情境。
以下的範例中，我們對Manager的使用類似於shared memory。但能夠共用更豐富的物件類型。

import multiprocessing def f(x, arr, l):    x.value = 3.14    arr[0] = 5    l.append(‘Hello‘) server = multiprocessing.Manager()x    = server.Value(‘d‘, 0.0)arr  = server.Array(‘i‘, range(10))l    = server.list() proc = multiprocessing.Process(target=f, args=(x, arr, l))proc.start()proc.join() print(x.value)print(arr)print(l)

Manager利用list()方法提供了表的共用方式。
實際上你能夠利用dict()來共用詞典，Lock()來共用threading.Lock(注意，我們共用的是threading.Lock。而不是進程的mutiprocessing.Lock。

後者本身已經實現了進程共用)等。
這樣Manager就同意我們共用很多其它樣的對象。

Python學習筆記18：標準庫之多進程（multiprocessing包）