一、進程：

進程：程序運行在操作系統上的一個實例，就稱之為進程。進程需要相應的系統資源：內存、時間片、pid。 創建進程： 首先要導入multiprocessing中的Process： 創建一個Process對象; 創建Process對象時，可以傳遞參數;

例1：不使用p.join()

import os
from multiprocessing import Process
import time
def pro_func(name):
for i in range(5):
print(f'子進程{
name+str(i)}開始執行')
time.sleep(2)
print(f'子進程{
name+str(i)}結束執行')
if __name__ == '__main__':
p=Process(target=pro_func,args=('kobe',))
p.start()
print('主進程執行結束')

執行結果：

主進程執行結束
子進程kobe0開始執行
子進程kobe0結束執行
子進程kobe1開始執行
子進程kobe1結束執行
子進程kobe2開始執行
子進程kobe2結束執行
子進程kobe3開始執行
子進程kobe3結束執行
子進程kobe4開始執行
子進程kobe4結束執行

例2：使用p.join()：阻塞函數，等待所有的子進程執行完畢後，主進程結束執行

import os
from multiprocessing import Process
import time
def pro_func(name):
for i in range(5):
print(f'子進程{
name+str(i)}開始執行')
time.sleep(2)
print(f'子進程{
name+str(i)}結束執行')
if __name__ == '__main__':
p=Process(target=pro_func,args=('kobe',))
p.start()
p.join()
print('主進程執行結束')

執行結果：

子進程kobe0開始執行
子進程kobe0結束執行
子進程kobe1開始執行
子進程kobe1結束執行
子進程kobe2開始執行
子進程kobe2結束執行
子進程kobe3開始執行
子進程kobe3結束執行
子進程kobe4開始執行
子進程kobe4結束執行
主進程執行結束

例3：p.terminate()：殺死子進程

import os
from multiprocessing import Process
import time
def pro_func(name):
for i in range(5):
print(f'子進程{
name+str(i)}開始執行')
time.sleep(2)
print(f'子進程{
name+str(i)}結束執行')
if __name__ == '__main__':
p=Process(target=pro_func,args=('kobe',))
p.start()
p.terminate()
p.join()
print('主進程執行結束')

執行結果：

主進程執行結束

二、進程之間的通信-Queue

在初始化Queue()對象時（例如q=Queue(),若在括號中沒有指定最大可接受的消息數量，獲數量為負值時，那麼就代表可接受的消息數量沒有上限一直到內存盡頭）

Queue.qsize():返回當前隊列包含的消息數量
Queue.empty():如果隊列為空，返回True，反之False
Queue.full():如果隊列滿了，返回True,反之False
Queue.get([block[,timeout]]):獲取隊列中的一條消息，然後將其從隊列中移除，block默認
值為True。

如果block使用默認值，且沒有設置timeout（單位秒),消息隊列如果為空，此時程序將被阻塞（停在讀中狀態），直到消息隊列讀到消息為止，如果設置了timeout，則會等待timeout秒，若還沒讀取到任何消息，則拋出“Queue.Empty"異常：

Queue.put(item,[block[,timeout]]):將item消息寫入隊列，block默認值為True; 如果block使用默認值，且沒有設置timeout（單位秒），消息隊列如果已經沒有空間可寫入，此時程序將被阻塞（停在寫入狀態），直到從消息隊列騰出空間為止，如果設置了timeout，則會等待timeout秒，若還沒空間，則拋出”Queue.Full"異常 如果block值為False，消息隊列如果沒有空間可寫入，則會立刻拋出"Queue.Full"異常; Queue.put_nowait(item):相當Queue.put(item,False)

例4：

from multiprocessing import Process,Queue
import os,time,random
def write(q):
for i in range(6):
print(f'生產產品{
i}')
q.put(f'生產產品{
i},添加到隊列中')
time.sleep(2)
def read(q):
while True:
if not q.empty():
value=q.get(True)
print(f'獲取到了產品{
value}')
time.sleep(2)
else:
break
if __name__ == '__main__':
q=Queue()
pw=Process(target=write,args=(q,))
pr=Process(target=read,args=(q,))
pw.start()
pr.start()
pw.join()
pr.join()
print('所有數據都寫入並且讀完')

執行結果：

生產產品0
獲取到了產品生產產品0,添加到隊列中
生產產品1
獲取到了產品生產產品1,添加到隊列中
生產產品2
獲取到了產品生產產品2,添加到隊列中
生產產品3
獲取到了產品生產產品3,添加到隊列中
生產產品4
獲取到了產品生產產品4,添加到隊列中
生產產品5
獲取到了產品生產產品5,添加到隊列中
所有數據都寫入並且讀完

三、進程池中使用Queue

如果要使用Pool創建進程，就需要使用multiprocessing.Manager()中的Queue(),而不是multiprocessing.Queue(),否則會得到如下的錯誤信息：
RuntimeError： Queue objects should only be shared between processs through inheritance

例5

from multiprocessing import Manager,Pool
import os,time,random
def write(q):
for i in range(6):
q.put(f'產品{
i}')
print(f'產品{
i}生產完成')
time.sleep(1)
def read(q):
while True:
if not q.empty():
value=q.get(True)
print(f'獲取到了{
value}')
time.sleep(2)
if __name__ == '__main__':
print(f'主進程開始執行，進程號為{
os.getpid()}')
q=Manager().Queue()
po=Pool(3)
po.apply_async(func=write,args=(q,))
po.apply_async(func=read,args=(q,))
po.close()
po.join()
print(f'主進程結束執行，進程號為{
os.getpid()}')

執行結果