多進(jìn)程

• fork
  Unix/Linux操作系統(tǒng)提供了一個fork()系統(tǒng)調(diào)用，它非常特殊。普通的函數(shù)調(diào)用，調(diào)用一次，返回一次，但是fork()調(diào)用一次，返回兩次，因為操作系統(tǒng)自動把當(dāng)前進(jìn)程（稱為父進(jìn)程）復(fù)制了一份（稱為子進(jìn)程），然后，分別在父進(jìn)程和子進(jìn)程內(nèi)返回。

import os

print('Process (%s) start...' % os.getpid())  #getpid()當(dāng)前進(jìn)程
# Only works on Unix/Linux/Mac:
pid = os.fork()
if pid == 0:            #子進(jìn)程返回0
    print('I am child process (%s) and my parent is %s.' % (os.getpid(), os.getppid())) #getppid當(dāng)前進(jìn)程父進(jìn)程
else:                   #父進(jìn)程返回子進(jìn)程的ID
    print('I (%s) just created a child process (%s).' % (os.getpid(), pid))

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

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

• multiprocessing
  由于Python是跨平臺的，自然也應(yīng)該提供一個跨平臺的多進(jìn)程支持。multiprocessing模塊就是跨平臺版本的多進(jìn)程模塊。
  下面的例子演示了啟動一個子進(jìn)程并等待其結(jié)束：

from multiprocessing import Process
import os

# 子進(jìn)程要執(zhí)行的代碼
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()                 #join()方法可以等待子進(jìn)程結(jié)束后再繼續(xù)往下運(yùn)行，通常用于進(jìn)程間的同步。
    print('Child process end.')

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

• Bool
  如果要啟動大量的子進(jìn)程，可以用進(jìn)程池的方式批量創(chuàng)建子進(jìn)程

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.

對Pool對象調(diào)用join()方法會等待所有子進(jìn)程執(zhí)行完畢，調(diào)用join()之前必須先調(diào)用close()，調(diào)用close()之后就不能繼續(xù)添加新的Process了。

• 進(jìn)程間通信

from multiprocessing import Process, Queue
import os, time, random

# 寫數(shù)據(jù)進(jìn)程執(zhí)行的代碼:
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())

# 讀數(shù)據(jù)進(jìn)程執(zhí)行的代碼:
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__':
    # 父進(jìn)程創(chuàng)建Queue，并傳給各個子進(jìn)程：
    q = Queue()
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))
    # 啟動子進(jìn)程pw，寫入:
    pw.start()
    # 啟動子進(jìn)程pr，讀取:
    pr.start()
    # 等待pw結(jié)束:
    pw.join()
    # pr進(jìn)程里是死循環(huán)，無法等待其結(jié)束，只能強(qiáng)行終止:
    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.

線程

大多數(shù)情況下使用threading模塊，啟動一個線程就是把一個函數(shù)傳入并創(chuàng)建Thread實例，然后調(diào)用start()開始執(zhí)行：

import time, threading

# 新線程執(zhí)行的代碼:
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)

由于任何進(jìn)程默認(rèn)就會啟動一個線程，我們把該線程稱為主線程，主線程又可以啟動新的線程，Python的threading模塊有個current_thread()函數(shù)，它永遠(yuǎn)返回當(dāng)前線程的實例。