線程是最小的執行單元，而進程由至少一個線程組成。如何調度進程和線程，完全由操作系統決定，程序自己不能決定什麼時候執行，執行多長時間。
在 Python 中我們要同時執行多個任務怎麼辦？
有兩種解決方案：
- 啓動多個進程，每個進程雖然只有一個線程，但多個進程可以一塊執行多個任務。
- 啓動一個進程，在一個進程內啓動多個線程，這樣，多個線程也可以一塊執行多個任務。
- 啓動多個進程，每個進程再啓動多個線程，這樣同時執行的任務就更多了，當然這種模型更復雜，實際很少採用。
總結一下就是，多任務的實現有 3 種方式： - 多進程模式；
- 多線程模式；
- 多進程+多線程模式。
多進程（multiprocessing）
multiprocessing
由於 Python 是跨平臺的，自然也應該提供一個跨平臺的多進程支持。multiprocessing 模塊就是跨平臺版本的多進程模塊。
multiprocessing 模塊提供了一個 Process 類來代表一個進程對象，下面的例子演示了啓動一個子進程並等待其結束：
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.')
創建子進程時，只需要傳入一個執行函數和函數的參數，創建一個Process實例，用start()方法啓動，這樣創建進程比fork()還要簡單。
join()方法可以等待子進程結束後再繼續往下運行，通常用於進程間的同步。
結果如下：
Parent process 928.
Child process will start.
Run child process test (929)...
Process end.
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.')
代碼解讀：
對Pool對象調用join()方法會等待所有子進程執行完畢，調用join()之前必須先調用close()，調用close()之後就不能繼續添加新的Process了。
請注意輸出的結果，task 0，1，2，3是立刻執行的，而task 4要等待前面某個task完成後才執行，這是因爲Pool的默認大小在我的電腦上是4，因此，最多同時執行4個進程。
結果：
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.
子進程
很多時候，子進程並不是自身，而是一個外部進程。我們創建了子進程後，還需要控制子進程的輸入和輸出。
subprocess 模塊可以讓我們非常方便地啓動一個子進程，然後控制其輸入和輸出。
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
進程間通信
Process 之間肯定是需要通信的，操作系統提供了很多機制來實現進程間的通信。Python 的 multiprocessing 模塊包裝了底層的機制，提供了 Queue、Pipes 等多種方式來交換數據。
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.
小結
- 要實現 Python 跨平臺的多進程，可以使用 multiprocessing 模塊。
- 進程間通信是通過 Queue、Pipes 等實現的。