1. multiprocessing模組提供了一個Process類來代表一個程序物件：

  （1）   multiprocessing.Process(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)

• target 是函式名字，需要呼叫的函式
• args 函式需要的引數，以 tuple 的形式傳入
• 將daemon設定為True時，則主執行緒不必等待子程序，主執行緒結束則所有結束


• star() 方法啟動程序，
• join() 方法實現程序間的同步，等待所有程序退出。
• close() 用來阻止多餘的程序湧入程序池 Pool 造成程序阻塞。

下面的例子演示了啟動一個子程序並等待其結束

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', ))
    p.start()
    p.join()
    print('End')
 

輸入結果如下：

Parent process 26524.
Run child process test (13336)...
End

2. 如果要啟動大量的子程序，可以用程序池的方式批量建立子程序

from multiprocessing import Pool
import os, time, random

def 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)   # 建立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 24496.
Waiting for all subprocesses done...
Run task 0 (3540)...
Run task 1 (25984)...
Run task 2 (14092)...
Run task 3 (20700)...
Task 3 runs 0.99 seconds.
Run task 4 (20700)...
Task 2 runs 1.35 seconds.
Task 0 runs 1.44 seconds.
Task 1 runs 2.48 seconds.
Task 4 runs 2.63 seconds.
All subprocesses done.

將p.apply_async()換成p.apply()後的輸出為：

Run task 0 (12596)...
Task 0 runs 1.37 seconds.
Run task 1 (24548)...
Task 1 runs 0.59 seconds.
Run task 2 (21196)...
Task 2 runs 0.41 seconds.
Run task 3 (22572)...
Task 3 runs 0.42 seconds.
Run task 4 (12596)...
Task 4 runs 1.70 seconds.
Waiting for all subprocesses done...
All subprocesses done.

對Pool物件呼叫join()方法會等待所有子程序執行完畢，呼叫join()之前必須先呼叫close()，呼叫close()之後就不能繼續新增新的Process了。

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

其中：

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

3. 程序間通訊

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

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

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__':
    # 父程序建立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: 17372
Put A to queue...
Process to read: 23988
Get A from queue.
Put B to queue...
Get B from queue.
Put C to queue...
Get C from queue.

multiprocessing Queue使用方法：

• Queue.qsize()：返回當前佇列包含的訊息數量；
• Queue.empty()：如果佇列為空，返回True，反之False ；
• Queue.full()：如果佇列滿了，返回True,反之False；
• Queue.get():獲取佇列中的一條訊息，然後將其從列隊中移除，可傳參超時時長;
• Queue.get_nowait()：相當Queue.get(False),取不到值時觸發異常：Empty；
• Queue.put():將一個值新增進數列，可傳參超時時長;
• Queue.put_nowait():相當於Queue.get(False),當佇列滿了時報錯：Full。