對於操作系統來說, 一個任務就是一個進程（Process）

進程內的這些“子任務”稱為線程（Thread）

真正的並行執行多任務只能在多核CPU上實現

多任務的實現有3種方式：

　　多進程模式；
　　多線程模式；
　　多進程+多線程模式
Python既支持多進程, 又支持多線程

1 多進程

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

　　子進程永遠返回0, 而父進程返回子進程的ID, 進程只需要調用getppid()就可以拿到父進程的ID

　　在python中可以通過導入os模塊來完成一些系統的調用

　　os.getpid()可以返回當前進程的pid

　　os.fork()可以調用fork系統調用, 只不過只是支持linux系列的系統

1.1 multiprocessing

　　由於在windows上無法使用fork(), 所以在python中提供了模塊multiprocessing來形成子進程

　　導入multiprocessing模塊的方法是使用from multiprocessing import帶入

　　利用process函數來創建一個子進程

　　第一個參數可以是用target用於傳遞一個函數, 用於生成進程之後調用該方法

　　第二個參數是args傳遞的剩余參數

　　使用start()方法來啟動子進程

　　join()方法表示父進程要等待子進程執行完畢之後才能繼續往下執行, 通常用於進程間的同步

　　具體的使用實例如下

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.‘)
 

1.2 Pool

　　要創建大量的進程就需要使用進程池

　　同樣是multiprocessing模塊下的, 但是使用的函數是Pool

　　具體是Pool()可以傳入一個值用於設定子進程同時執行的數量, 返回一個進程池

　　Pool默認的大小是CPU的內核數量

　　進程池可以調用apply_async()函數來創建子進程, 同樣第一個參數可以綁定一個方法, 第二個參數args

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

　　具體創建代碼

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.‘)

1.3 子進程

　　如果不僅要創建執行子進程, 還需要控制進程的輸入和輸出, 那就需要使用subprocess模塊

　　具體代碼如下

import subprocess

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

1.4 進程間的通信

　　進程之間還需要通信, python通過Queue和Pipes來交換數據

　　下面是創建兩個進程, 一個是往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()

2 多線程

　　一個進程至少有一個線程

　　線程是操作系統直接支持的執行單元　　　　

　　在python中提供兩個模塊進程線程的操作, 一個是_thread, 一個是threading

　　其中_thread是低級模塊, threading是高級模塊, 對_thread進程了封裝, 一般只使用threading就行

　　啟動一個線程就是把一個函數傳入並創建Thread實例, 然後調用start()開始執行

　　由於任何進程默認就會啟動一個線程，我們把該線程稱為主線程, 主線程又可以啟動新的線程

　　Python的threading模塊有個current_thread()函數，它永遠返回當前線程的實例

　　主線程實例的名字叫MainThread，子線程的名字在創建時指定，我們用LoopThread命名子線程

　　名字僅僅在打印時用來顯示，完全沒有其他意義，如果不起名字Python就自動給線程命名為Thread-1，Thread-2……

　　具體代碼如下

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)

2.1 Lock

　　多線程和多進程的區別

　　多進程中, 同一個變量, 各自有一份拷貝, 互相不影響

　　多線程中, 所有變量都是有所有線程共享, 任何一個變量都可以被任何一個線程修改, 所以一定要註意同時修改一個變量的情況

　　因此可以使用鎖來實現對並發修改的控制

balance = 0
lock = threading.Lock()

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

第十六章-進程和線程