轉載自廖老師
要讓Python程式實現多程序（multiprocessing），我們先了解作業系統的相關知識。

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

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

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

import os

print('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上無法執行。由於Mac系統是基於BSD（Unix的一種）核心，所以，在Mac下執行是沒有問題的，推薦大家用Mac學Python！

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

multiprocessing

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

由於Python是跨平臺的，自然也應該提供一個跨平臺的多程序支援。multiprocessing

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',))
    print('Child process will start.')
    p.start()
    p.join()
    print('Child process end.')

執行結果如下：

Parent process 928.
Process will start.
Run child process test (929)...
Process end.

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

Pool

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

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)
    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 subprocess

print('$ 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 subprocess

print('$ 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

執行結果如下：

$ nslookup
Server:        192.168.19.4
Address:    192.168.19.4#53

Non-authoritative answer:
python.org    mail exchanger = 50 mail.python.org.

Authoritative answers can be found from:
mail.python.org    internet address = 82.94.164.166
mail.python.org    has AAAA address 2001:888:2000:d::a6


Exit code: 0

程序間通訊

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: 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等實現的。