Python多進程完成平行處理的方法介紹

本篇文章主要介紹了Python中使用多進程來實現平行處理的方法小結，具有一定的參考價值，感興趣的小夥伴們可以參考一下

進程和線程是電腦軟體領域裡很重要的概念，進程和線程有區別，也有著密切的聯絡，先來辨析一下這兩個概念：

1.定義

進程是具有一定獨立功能的程式關於某個資料集合上的一次運行活動,進程是系統進行資源分派和調度的一個獨立單位.
線程是進程的一個實體,是CPU調度和指派的基本單位,它是比進程更小的能獨立啟動並執行基本單位.線程自己基本上不擁有系統資源,只擁有一點在運行中必不可少的資源(如程式計數器,一組寄存器和棧),但是它可與同屬一個進程的其他的線程共用進程所擁有的全部資源.

2.關係

一個線程可以建立和撤銷另一個線程;同一個進程中的多個線程之間可以並發執行.

相對進程而言，線程是一個更加接近於執行體的概念，它可以與同進程中的其他線程共用資料，但擁有自己的棧空間，擁有獨立的執行序列。

3.區別

進程和線程的主要差別在於它們是不同的作業系統資源管理方式。進程有獨立的地址空間，一個進程崩潰後，在保護模式下不會對其它進程產生影響，而線程只是一個進程中的不同執行路徑。線程有自己的堆棧和局部變數，但線程之間沒有單獨的地址空間，一個線程死掉就等於整個進程死掉，所以多進程的程式要比多線程的程式健壯，但在進程切換時，耗費資源較大，效率要差一些。但對於一些要求同時進行並且又要共用某些變數的並行作業，只能用線程，不能用進程。

1) 簡而言之,一個程式至少有一個進程,一個進程至少有一個線程.

2) 線程的劃分尺度小於進程，使得多線程程式的並發性高。

3) 另外，進程在執行過程中擁有獨立的記憶體單元，而多個線程共用記憶體，從而極大地提高了程式的運行效率。

4) 線程在執行過程中與進程還是有區別的。每個獨立的線程有一個程式啟動並執行入口、順序執行序列和程式的出口。但是線程不能夠獨立執行，必須依存在應用程式中，由應用程式提供多個線程執行控制。

5) 從邏輯角度來看，多線程的意義在於一個應用程式中，有多個執行部分可以同時執行。但作業系統並沒有將多個線程看做多個獨立的應用，來實現進程的調度和管理以及資源分派。這就是進程和線程的重要區別。

4.優缺點

線程和進程在使用上各有優缺點：線程執行開銷小，但不利於資源的管理和保護；而進程正相反。同時，線程適合於在SMP機器上運行，而進程則可以跨機器遷移。

這篇文章主要講多進程在Python中的應用

Unix/Linux作業系統提供了一個fork()系統調用，它非常特殊。普通的函數調用，調用一次，返回一次，但是fork()調用一次，返回兩次，因為作業系統自動把當前進程（稱為父進程）複製了一份（稱為子進程），然後，分別在父進程和子進程內返回。

子進程永遠返回0，而父進程返回子進程的ID。這樣做的理由是，一個父進程可以fork出很多子進程，所以，父進程要記下每個子進程的ID，而子進程只需要調用getpid()就可以拿到父進程的ID。

python的os模組封裝了常見的系統調用，其中就包括fork，可以在Python程式中輕鬆建立子進程：

import osprint('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))

運行結果如下：

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

由於Windows沒有fork調用，上面的代碼在Windows上無法運行。

有了fork調用，一個進程在接到新任務時就可以複製出一個子進程來處理新任務，常見的Apache伺服器就是由父進程監聽連接埠，每當有新的http請求時，就fork出子進程來處理新的http請求。

multiprocessing

如果你打算編寫多進程的服務程式，Unix/linux無疑是正確的選擇。由於Windows沒有fork調用，難道在Windows上無法用Python編寫多進程的程式？

由於Python是跨平台的，自然也應該提供一個跨平台的多進程支援。multiprocessing模組就是跨平台版本的多進程模組。

multiprocessing模組提供了一個Process類來代表一個進程對象，下面的例子示範了啟動一個子進程並等待其結束：

from multiprocessing import Processimport 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.')

建立子進程時，只需要傳入一個執行函數和函數的參數，建立一個Process執行個體，用start()方法啟動，這樣建立進程比fork()還要簡單。

join()方法可以等待子進程結束後再繼續往下運行，通常用於進程間的同步。

Pool

如果要啟動大量的子進程，可以用進程池的方式大量建立子進程：

from multiprocessing import Poolimport os, time, randomdef long_time_task(name):  print('Run task %s (%s)...' % (name, os.getpid()))  start = time.time()  time.sleep(random.random() * 3)  end = time.time()  print('Task %s runs %0.2f seconds.' % (name, (end - start)))if __name__=='__main__':  print('Parent process %s.' % os.getpid())  p = Pool(4)  for i in range(5):    p.apply_async(long_time_task, args=(i,))  print('Waiting for all subprocesses done...')  p.close()  p.join()  print('All subprocesses done.')

執行結果如下：

Parent process 669.
Waiting for all subprocesses done...
Run task 0 (671)...
Run task 1 (672)...
Run task 2 (673)...
Run task 3 (674)...
Task 2 runs 0.14 seconds.
Run task 4 (673)...
Task 1 runs 0.27 seconds.
Task 3 runs 0.86 seconds.
Task 0 runs 1.41 seconds.
Task 4 runs 1.91 seconds.
All subprocesses done.

代碼解讀：

對Pool對象調用join()方法會等待所有子進程執行完畢，調用join()之前必須先調用close()，調用close()之後就不能繼續添加新的Process了。

請注意輸出的結果，task 0，1，2，3是立刻執行的，而task 4要等待前面某個task完成後才執行，這是因為Pool的預設大小在我的電腦上是4，因此，最多同時執行4個進程。這是Pool有意設計的限制，並不是作業系統的限制。如果改成：

p = Pool(5)

就可以同時跑5個進程。

由於Pool的預設大小是CPU的核心數，如果你不幸擁有8核CPU，你要提交至少9個子進程才能看到上面的等待效果。

子進程

很多時候，子進程並不是自身，而是一個外部進程。我們建立了子進程後，還需要控制子進程的輸入和輸出。

subprocess模組可以讓我們非常方便地啟動一個子進程，然後控制其輸入和輸出。

下面的例子示範了如何在Python代碼中運行命令nslookup www.python.org，這和命令列直接啟動並執行效果是一樣的：

import subprocessprint('$ nslookup www.python.org')r = subprocess.call(['nslookup', 'www.python.org'])print('Exit code:', r)

運行結果：

$ nslookup www.python.org
Server: 192.168.19.4
Address: 192.168.19.4#53
Non-authoritative answer:
www.python.org canonical name = python.map.fastly.net.
Name: python.map.fastly.net
Address: 199.27.79.223
Exit code: 0

如果子進程還需要輸入，則可以通過communicate()方法輸入：

import subprocessprint('$ nslookup')p = subprocess.Popen(['nslookup'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)output, err = p.communicate(b'set q=mx\npython.org\nexit\n')print(output.decode('utf-8'))print('Exit code:', p.returncode)

上面的代碼相當於在命令列執行命令nslookup，然後手動輸入：

set q=mx
python.org
exit

處理序間通訊

Process之間肯定是需要通訊的，作業系統提供了很多機制來實現進程間的通訊。Python的multiprocessing模組封裝了底層的機制，提供了Queue、Pipes等多種方式來交換資料。

我們以Queue為例，在父進程中建立兩個子進程，一個往Queue裡寫資料，一個從Queue裡讀資料：

from multiprocessing import Process, Queueimport 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__':  # 父進程建立Queue，並傳給各個子進程：  q = Queue()  pw = Process(target=write, args=(q,))  pr = Process(target=read, args=(q,))  # 啟動子進程pw，寫入:  pw.start()  # 啟動子進程pr，讀取:  pr.start()  # 等待pw結束:  pw.join()  # pr進程裡是死迴圈，無法等待其結束，只能強行終止:  pr.terminate()

運行結果如下：

Process to write: 50563
Put A to queue...
Process to read: 50564
Get A from queue.
Put B to queue...
Get B from queue.
Put C to queue...
Get C from queue.

在Unix/Linux下，multiprocessing模組封裝了fork()調用，使我們不需要關注fork()的細節。由於Windows沒有fork調用，因此，multiprocessing需要“類比”出fork的效果，父進程所有Python對象都必須通過pickle序列化再傳到子進程去，所有，如果multiprocessing在Windows下調用失敗了，要先考慮是不是pickle失敗了。

小結

在Unix/Linux下，可以使用fork()調用實現多進程。

要實現跨平台的多進程，可以使用multiprocessing模組。

處理序間通訊是通過Queue、Pipes等實現的。

多線程

多任務可以由多進程完成，也可以由一個進程內的多線程完成。進程是由若干線程組成的，一個進程至少有一個線程。

由於線程是作業系統直接支援的執行單元，因此，進階語言通常都內建多線程的支援，Python也不例外，並且，Python的線程是真正的Posix Thread，而不是類比出來的線程。

Python的標準庫提供了兩個模組：_thread 和 threading，_thread是低級模組，threading是進階模組，對_thread進行了封裝。絕大多數情況下，我們只需要使用threading這個進階模組。

啟動一個線程就是把一個函數傳入並建立Thread執行個體，然後調用start()開始執行：

import time, threading# 新線程執行的代碼:def loop():  print('thread %s is running...' % threading.current_thread().name)  n = 0  while n < 5:    n = n + 1    print('thread %s >>> %s' % (threading.current_thread().name, n))    time.sleep(1)  print('thread %s ended.' % threading.current_thread().name)print('thread %s is running...' % threading.current_thread().name)t = threading.Thread(target=loop, name='LoopThread')t.start()t.join()print('thread %s ended.' % threading.current_thread().name)thread MainThread is running...thread LoopThread is running...thread LoopThread >>> 1thread LoopThread >>> 2thread LoopThread >>> 3thread LoopThread >>> 4thread LoopThread >>> 5thread LoopThread ended.thread MainThread ended.

由於任何進程預設就會啟動一個線程，我們把該線程稱為主線程，主線程又可以啟動新的線程，Python的threading模組有個current_thread()函數，它永遠返回當前線程的執行個體。主線程執行個體的名字叫MainThread，子線程的名字在建立時指定，我們用LoopThread命名子線程。名字僅僅在列印時用來顯示，完全沒有其他意義，如果不起名字Python就自動給線程命名為Thread-1，Thread-2……

Lock

多線程和多進程最大的不同在於，多進程中，同一個變數，各自有一份拷貝存在於每個進程中，互不影響，而多線程中，所有變數都由所有線程共用，所以，任何一個變數都可以被任何一個線程修改，因此，線程之間共用資料最大的危險在於多個線程同時改一個變數，把內容給改亂了。

來看看多個線程同時操作一個變數怎麼把內容給改亂了：

import time, threading# 假定這是你的銀行存款:balance = 0def change_it(n):  # 先存後取，結果應該為0:  global balance  balance = balance + n  balance = balance - ndef run_thread(n):  for i in range(100000):    change_it(n)t1 = threading.Thread(target=run_thread, args=(5,))t2 = threading.Thread(target=run_thread, args=(8,))t1.start()t2.start()t1.join()t2.join()print(balance)

我們定義了一個共用變數balance，初始值為0，並且啟動兩個線程，先存後取，理論上結果應該為0，但是，由於線程的調度是由作業系統決定的，當t1、t2交替執行時，只要迴圈次數足夠多，balance的結果就不一定是0了。

原因是因為進階語言的一條語句在CPU執行時是若干條語句，即使一個簡單的計算：

balance = balance + n

也分兩步：

1. 計算balance + n，存入臨時變數中；

2. 將臨時變數的值賦給balance。

也就是可以看成：

x = balance + nbalance = x

資料錯誤的原因：是因為修改balance需要多條語句，而執行這幾條語句時，線程可能中斷，從而導致多個線程把同一個對象的內容改亂了。

兩個線程同時一存一取，就可能導致餘額不對，你肯定不希望你的銀行存款莫名其妙地變成了負數，所以，我們必須確保一個線程在修改balance的時候，別的線程一定不能改。

如果我們要確保balance計算正確，就要給change_it()上一把鎖，當某個線程開始執行change_it()時，我們說，該線程因為獲得了鎖，因此其他線程不能同時執行change_it()，只能等待，直到鎖被釋放後，獲得該鎖以後才能改。由於鎖只有一個，無論多少線程，同一時刻最多隻有一個線程持有該鎖，所以，不會造成修改的衝突。建立一個鎖就是通過threading.Lock()來實現：

balance = 0lock = threading.Lock()def run_thread(n):  for i in range(100000):    # 先要擷取鎖:    lock.acquire()    try:      # 放心地改吧:      change_it(n)    finally:      # 改完了一定要釋放鎖:      lock.release()

當多個線程同時執行lock.acquire()時，只有一個線程能成功地擷取鎖，然後繼續執行代碼，其他線程就繼續等待直到獲得鎖為止。

獲得鎖的線程用完後一定要釋放鎖，否則那些苦苦等待鎖的線程將永遠等待下去，成為死線程。所以我們用try...finally來確保鎖一定會被釋放。

鎖的好處就是確保了某段關鍵代碼只能由一個線程從頭到尾完整地執行，壞處當然也很多，首先是阻止了多線程並發執行，包含鎖的某段代碼實際上只能以單線程模式執行，效率就大大地下降了。其次，由於可以存在多個鎖，不同的線程持有不同的鎖，並試圖擷取對方持有的鎖時，可能會造成死結，導致多個線程全部掛起，既不能執行，也無法結束，只能靠作業系統強制終止。

多核CPU

如果你不幸擁有一個多核CPU，你肯定在想，多核應該可以同時執行多個線程。

如果寫一個死迴圈的話，會出現什麼情況呢？

開啟Mac OS X的Activity Monitor，或者Windows的Task Manager，都可以監控某個進程的CPU使用率。

我們可以監控到一個死迴圈線程會100%佔用一個CPU。如果有兩個死迴圈線程，在多核CPU中，可以監控到會佔用200%的CPU，也就是佔用兩個CPU核心。要想把N核CPU的核心全部跑滿，就必須啟動N個死迴圈線程。

試試用Python寫個死迴圈：

import threading, multiprocessingdef loop():  x = 0  while True:    x = x ^ 1for i in range(multiprocessing.cpu_count()):  t = threading.Thread(target=loop)  t.start()

啟動與CPU核心數量相同的N個線程，在4核CPU上可以監控到CPU佔用率僅有102%，也就是僅使用了一核。

但是用C、C++或Java來改寫相同的死迴圈，直接可以把全部核心跑滿，4核就跑到400%，8核就跑到800%，為什麼Python不行呢？

因為Python的線程雖然是真正的線程，但解譯器執行代碼時，有一個GIL鎖：Global Interpreter Lock，任何Python線程執行前，必須先獲得GIL鎖，然後，每執行100條位元組碼，解譯器就自動釋放GIL鎖，讓別的線程有機會執行。這個GIL全域鎖實際上把所有線程的執行代碼都給上了鎖，所以，多線程在Python中只能交替執行，即使100個線程跑在100核CPU上，也只能用到1個核。

GIL是Python解譯器設計的曆史遺留問題，通常我們用的解譯器是官方實現的CPython，要真正利用多核，除非重寫一個不帶GIL的解譯器。

所以，在Python中，可以使用多線程，但不要指望能有效利用多核。如果一定要通過多線程利用多核，那隻能通過C擴充來實現，不過這樣就失去了Python簡單易用的特點。

不過，也不用過於擔心，Python雖然不能利用多線程實現多核任務，但可以通過多進程實現多核任務。多個Python進程有各自獨立的GIL鎖，互不影響。

多線程編程，模型複雜，容易發生衝突，必須用鎖加以隔離，同時，又要小心死結的發生。

Python解譯器由於設計時有GIL全域鎖，導致了多線程無法利用多核。

ThreadLocal

在多線程環境下，每個線程都有自己的資料。一個線程使用自己的局部變數比使用全域變數好，因為局部變數只有線程自己能看見，不會影響其他線程，而全域變數的修改必須加鎖。但是局部變數也有問題，就是在函數調用的時候，傳遞起來很麻煩：

import threading# 建立全域ThreadLocal對象:local_school = threading.local()def process_student():  # 擷取當前線程關聯的student:  std = local_school.student  print('Hello, %s (in %s)' % (std, threading.current_thread().name))def process_thread(name):  # 綁定ThreadLocal的student:  local_school.student = name  process_student()t1 = threading.Thread(target= process_thread, args=('Alice',), name='Thread-A')t2 = threading.Thread(target= process_thread, args=('Bob',), name='Thread-B')t1.start()t2.start()t1.join()t2.join()

全域變數local_school就是一個ThreadLocal對象，每個Thread對它都可以讀寫student屬性，但互不影響。你可以把local_school看成全域變數，但每個屬性如local_school.student都是線程的局部變數，可以任意讀寫而互不干擾，也不用管理鎖的問題，ThreadLocal內部會處理。

可以理解為全域變數local_school是一個dict，不但可以用local_school.student，還可以綁定其他變數，如local_school.teacher等等。

ThreadLocal最常用的地方就是為每個線程綁定一個資料庫連接，HTTP請求，使用者身份資訊等，這樣一個線程的所有調用到的處理函數都可以非常方便地訪問這些資源。

一個ThreadLocal變數雖然是全域變數，但每個線程都只能讀寫自己線程的獨立副本，互不干擾。ThreadLocal解決了參數在一個線程中各個函數之間互相傳遞的問題。

進程 vs. 線程

我們介紹了多進程和多線程，這是實現多任務最常用的兩種方式。現在，我們來討論一下這兩種方式的優缺點。

首先，要實現多任務，通常我們會設計Master-Worker模式，Master負責分配任務，Worker負責執行任務，因此，多任務環境下，通常是一個Master，多個Worker。

如果用多進程實現Master-Worker，主進程就是Master，其他進程就是Worker。

如果用多線程實現Master-Worker，主線程就是Master，其他線程就是Worker。

多進程模式最大的優點就是穩定性高，因為一個子進程崩潰了，不會影響主進程和其他子進程。（當然主進程掛了所有進程就全掛了，但是Master進程只負責分配任務，掛掉的機率低）著名的Apache最早就是採用多進程模式。

多進程模式的缺點是建立進程的代價大，在Unix/Linux系統下，用fork調用還行，在Windows下建立進程開銷巨大。另外，作業系統能同時啟動並執行進程數也是有限的，在記憶體和CPU的限制下，如果有幾千個進程同時運行，作業系統連調度都會成問題。

多線程模式通常比多進程快一點，但是也快不到哪去，而且，多線程模式致命的缺點就是任何一個線程掛掉都可能直接造成整個進程崩潰，因為所有線程共用進程的記憶體。在Windows上，如果一個線程執行的代碼出了問題，你經常可以看到這樣的提示：“該程式執行了非法操作，即將關閉”，其實往往是某個線程出了問題，但是作業系統會強制結束整個進程。

在Windows下，多線程的效率比多進程要高，所以微軟的IIS伺服器預設採用多線程模式。由於多線程存在穩定性的問題，IIS的穩定性就不如Apache。為了緩解這個問題，IIS和Apache現在又有多進程+多線程的混合模式，真是把問題越搞越複雜。

線程切換

無論是多進程還是多線程，只要數量一多，效率肯定上不去，為什麼呢？

我們打個比方，假設你不幸正在準備中考，每天晚上需要做語文、數學、英語、物理、化學這5科的作業，每項作業耗時1小時。

如果你先花1小時做語文作業，做完了，再花1小時做數學作業，這樣，依次全部做完，一共花5小時，這種方式稱為單任務模型，或者批處理任務模型。

假設你打算切換到多任務模型，可以先做1分鐘語文，再切換到數學作業，做1分鐘，再切換到英語，以此類推，只要切換速度足夠快，這種方式就和單核CPU執行多任務是一樣的了，以幼兒園小朋友的眼光來看，你就正在同時寫5科作業。

但是，切換作業是有代價的，比如從語文切到數學，要先收拾桌子上的語文書本、鋼筆（這叫儲存現場），然後，開啟數學課本、找出圓規直尺（這叫準備新環境），才能開始做數學作業。作業系統在切換進程或者線程時也是一樣的，它需要先儲存當前執行的現場環境（CPU寄存器狀態、記憶體頁等），然後，把新任務的執行環境準備好（恢複上次的寄存器狀態，切換記憶體頁等），才能開始執行。這個切換過程雖然很快，但是也需要耗費時間。如果有幾千個任務同時進行，作業系統可能就主要忙著切換任務，根本沒有多少時間去執行任務了，這種情況最常見的就是硬碟狂響，點視窗無反應，系統處於假死狀態。

所以，多任務一旦多到一個限度，就會消耗掉系統所有的資源，結果效率急劇下降，所有任務都做不好。

計算密集型 vs. IO密集型

是否採用多任務的第二個考慮是任務的類型。我們可以把任務分為計算密集型和IO密集型。

計算密集型任務的特點是要進行大量的計算，消耗CPU資源，比如計算圓周率、對視頻進行高清解碼等等，全靠CPU的運算能力。這種計算密集型任務雖然也可以用多任務完成，但是任務越多，花在任務切換的時間就越多，CPU執行任務的效率就越低，所以，要最高效地利用CPU，計算密集型任務同時進行的數量應當等於CPU的核心數。

計算密集型任務由於主要消耗CPU資源，因此，代碼運行效率至關重要。Python這樣的指令碼語言運行效率很低，完全不適合計算密集型任務。對於計算密集型任務，最好用C語言編寫。

第二種任務的類型是IO密集型，涉及到網路、磁碟IO的任務都是IO密集型任務，這類任務的特點是CPU消耗很少，任務的大部分時間都在等待IO操作完成（因為IO的速度遠遠低於CPU和記憶體的速度）。對於IO密集型任務，任務越多，CPU效率越高，但也有一個限度。常見的大部分任務都是IO密集型任務，比如Web應用。

IO密集型任務執行期間，99%的時間都花在IO上，花在CPU上的時間很少，因此，用運行速度極快的c語言替換用Python這樣運行速度極低的指令碼語言，完全無法提升運行效率。對於IO密集型任務，最合適的語言就是開發效率最高（代碼量最少）的語言，指令碼語言是首選，C語言最差。

非同步IO

考慮到CPU和IO之間巨大的速度差異，一個任務在執行的過程中大部分時間都在等待IO操作，單進程單執行緒模式會導致別的任務無法並存執行，因此，我們才需要多進程模型或者多執行緒模式來支援多任務並發執行。

現代作業系統對IO操作已經做了巨大的改進，最大的特點就是支援非同步IO。如果充分利用作業系統提供的非同步IO支援，就可以用單進程單執行緒模式來執行多任務，這種全新的模型稱為事件驅動模型，Nginx就是支援非同步IO的Web伺服器，它在單核CPU上採用單進程模型就可以高效地支援多任務。在多核CPU上，可以運行多個進程（數量與CPU核心數相同），充分利用多核CPU。由於系統總的進程數量十分有限，因此作業系統調度非常高效。用非同步IO編程模型來實現多任務是一個主要的趨勢。

對應到Python語言，單進程的非同步編程模型稱為協程，有了協程的支援，就可以基於事件驅動編寫高效的多任務程式。我們會在後面討論如何編寫協程。

分布式進程

在Thread和Process中，應當優選Process，因為Process更穩定，而且，Process可以分布到多台機器上，而Thread最多隻能分布到同一台機器的多個CPU上。

Python的multiprocessing模組不但支援多進程，其中managers子模組還支援把多進程分布到多台機器上。一個服務進程可以作為調度者，將任務分布到其他多個進程中，依靠網路通訊。由於managers模組封裝很好，不必瞭解網路通訊的細節，就可以很容易地編寫分布式多進程程式。

舉個例子：如果我們已經有一個通過Queue通訊的多進程程式在同一台機器上運行，現在，由於處理任務的進程任務繁重，希望把發送任務的進程和處理任務的進程分布到兩台機器上。怎麼用分布式進程實現？

原有的Queue可以繼續使用，但是，通過managers模組把Queue通過網路暴露出去，就可以讓其他機器的進程訪問Queue了。

我們先看服務進程，服務進程負責啟動Queue，把Queue註冊到網路上，然後往Queue裡面寫入任務：

import random, time, queuefrom multiprocessing.managers import BaseManager# 發送任務的隊列:task_queue = queue.Queue()# 接收結果的隊列:result_queue = queue.Queue()# 從BaseManager繼承的QueueManager:class QueueManager(BaseManager):  pass# 把兩個Queue都註冊到網路上, callable參數關聯了Queue對象:QueueManager.register('get_task_queue', callable=lambda: task_queue)QueueManager.register('get_result_queue', callable=lambda: result_queue)# 綁定連接埠5000, 設定驗證碼'abc':manager = QueueManager(address=('', 5000), authkey=b'abc')# 啟動Queue:manager.start()# 獲得通過網路訪問的Queue對象:task = manager.get_task_queue()result = manager.get_result_queue()# 放幾個任務進去:for i in range(10):  n = random.randint(0, 10000)  print('Put task %d...' % n)  task.put(n)# 從result隊列讀取結果:print('Try get results...')for i in range(10):  r = result.get(timeout=10)  print('Result: %s' % r)# 關閉:manager.shutdown()print('master exit.')

當我們在一台機器上寫多進程程式時，建立的Queue可以直接拿來用，但是，在分布式多進程環境下，新增工作到Queue不可以直接對原始的task_queue進行操作，那樣就繞過了QueueManager的封裝，必須通過manager.get_task_queue()獲得的Queue介面添加。

然後，在另一台機器上啟動任務進程（本機上啟動也可以）：

import time, sys, queuefrom multiprocessing.managers import BaseManager# 建立類似的QueueManager:class QueueManager(BaseManager):  pass# 由於這個QueueManager只從網路上擷取Queue，所以註冊時只提供名字:QueueManager.register('get_task_queue')QueueManager.register('get_result_queue')# 串連到伺服器，也就是運行task_master.py的機器:server_addr = '127.0.0.1'print('Connect to server %s...' % server_addr)# 連接埠和驗證碼注意保持與task_master.py設定的完全一致:m = QueueManager(address=(server_addr, 5000), authkey=b'abc')# 從網路連接:m.connect()# 擷取Queue的對象:task = m.get_task_queue()result = m.get_result_queue()# 從task隊列取任務,並把結果寫入result隊列:for i in range(10):  try:    n = task.get(timeout=1)    print('run task %d * %d...' % (n, n))    r = '%d * %d = %d' % (n, n, n*n)    time.sleep(1)    result.put(r)  except Queue.Empty:    print('task queue is empty.')# 處理結束:print('worker exit.')

任務進程要通過網路連接到服務進程，所以要指定服務進程的IP。http://www.jb51.net/article/65112.htm

小結

Python的分布式進程介面簡單，封裝良好，適合需要把繁重任務分布到多台機器的環境下。

注意Queue的作用是用來傳遞任務和接收結果，每個任務的描述資料量要盡量小。比如發送一個處理記錄檔的任務，就不要發送幾百兆的記錄檔本身，而是發送記錄檔存放的完整路徑，由Worker進程再去共用的磁碟上讀取檔案。