目錄
線程是最小的執行單元，而進程由至少一個線程組成。
多進程
Unix/Linux操作系統提供了一個fork()系統調用，fork()調用一次，返回兩次，因爲操作系統自動把當前進程（稱爲父進程）複製了一份（稱爲子進程），然後，分別在父進程和子進程內返回。
子進程永遠返回0，而父進程返回子進程的ID。這樣做的理由是，一個父進程可以fork出很多子進程，所以，父進程要記下每個子進程的ID，而子進程只需要調用getppid()就可以拿到父進程的ID。
Python的os模塊封裝了常見的系統調用
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:i
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.
multiprocessing模塊提供了一個Process類來代表一個進程對象，下面的例子演示了啓動一個子進程並等待其結束：
group參數未使用，值始終爲None。
target表示調用的對象，就是子進程要執行的任務。
name可以爲子進程命名。
args指定的爲傳結target函數的位置參數，是一個元組形式，必須有逗號，如：args=('monicx',)
kwargs指定的爲傳結target函數的關鍵字參數，是一個字典，如kwargs={'name':'monicx','age':18}
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.
Child process will start.
Run child process test (929)...
Process end.
實例化類Process創建子進程
Process類的方法有：
start():啓動進程，並調用該子進程中的p.run()
run():進程啓動進運行的方法，就是它去調用target指定的函數，我們自定義類的類中一定要實現該方法。
terminate():強制終止進程。不會進行任何清理操作，如果p創建了子進程，該子進程就成了殭屍進程，使用此方法需要小心：如果此進程還保存了一個鎖那麼也將不會釋放這個鎖，進而導致死鎖。
is_alive():判斷進程是否是“活着”的狀態。
join(timeout):讓主線程等待某一子進程結束，才繼續執行主進程。timeout是可選的超時時間。超過一個時間主進程就不等待了
方式二：通過繼承實現進程
from multiprocessing import Process
import time
class MyProcess(Process):
def __init__(self,name):
super(MyProcess,self).__init__()
self.name=name
def run(self):
print("%s is running " %self.name)
time.sleep(2)
print('%s is done'%self.name)
if __name__ == '__main__':
p=MyProcess('monicx')
p.start()#就是調用run()方法。
print('====主')
運行結果：
====主
monicx is running
monicx is done
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.
調用join()之前必須先調用close()，調用close()之後就不能繼續添加新的Process了。
子進程
子進程並不是自身，而是一個外部進程。我們創建了子進程後，還需要控制子進程的輸入和輸出。
subprocess模塊可以方便地啓動一個子進程，然後控制其輸入和輸出。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.