【示例-多任務】Python多進程multiprocessing模塊

multiprocessing模塊就是跨平臺版本的多進程模塊，提供了一個Process類來代表一個進程對象
更多內置方法見 官方文檔： multiprocessing — 基於進程的並行

1. 進程的創建

1.1 創建 & 獲取Pid

import os
import time
from multiprocessing import Process


def run_proc():
    """子進程要執行的代碼"""
    print('子進程運行中，pid=%d...' % os.getpid())  # os.getpid獲取當前進程的進程號
    print('子進程將要結束...')

if __name__ == '__main__':
    print('父進程pid: %d' % os.getpid())  # os.getpid獲取當前進程的進程號
    p = Process(target=run_proc)
    p.start()

1.2 語法結構

Process([group [, target [, name [, args [, kwargs]]]]])

• target：如果傳遞了函數的引用，可以任務這個子進程就執行這裏的代碼
• args：給target指定的函數傳遞的參數，以元組的方式傳遞
• kwargs：給target指定的函數傳遞命名參數
• name：給進程設定一個名字，可以不設定
• group：指定進程組，大多數情況下用不到

Process創建的實例對象的常用方法：

• start()：啓動子進程實例（創建子進程）
• is_alive()：判斷進程子進程是否還在活着
• join([timeout])：是否等待子進程執行結束，或等待多少秒
• terminate()：不管任務是否完成，立即終止子進程

Process創建的實例對象的常用屬性：

• name：當前進程的別名，默認爲Process-N，N爲從1開始遞增的整數
• pid：當前進程的pid（進程號）

1.3 子進程傳參

import os
from time import sleep
from multiprocessing import Process


def run_proc(name, age, **kwargs):
    for i in range(10):
        print('子進程運行中，name= %s,age=%d ,pid=%d...' % (name, age, os.getpid()))
        print(kwargs)
        sleep(0.2)

if __name__=='__main__':
    p = Process(target=run_proc, args=('test',18), kwargs={"m":20})
    p.start()
    sleep(1)  # 1秒中之後，立即結束子進程
    p.terminate()
    p.join()

1.4 多進程 不共享 全局變量

import os
import time
from multiprocessing import Process


nums = [11, 22]

def work1():
    """子進程要執行的代碼"""
    print("in process1 pid=%d ,nums=%s" % (os.getpid(), nums))
    for i in range(3):
        nums.append(i)
        time.sleep(1)
        print("in process1 pid=%d ,nums=%s" % (os.getpid(), nums))

def work2():
    """子進程要執行的代碼"""
    print("in process2 pid=%d ,nums=%s" % (os.getpid(), nums))

if __name__ == '__main__':
    p1 = Process(target=work1)
    p1.start()
    p1.join()

    p2 = Process(target=work2)
    p2.start()

2. 進程間的通信Queue

Process之間有時需要通信，操作系統提供了很多機制來實現進程間的通信。

2.1 Queue的使用

可以使用multiprocessing模塊的Queue實現多進程之間的數據傳遞，Queue本身是一個消息列隊程序，首先用一個小實例來演示一下Queue的工作原理：

# coding=utf-8
from multiprocessing import Queue

q=Queue(3) #初始化一個Queue對象，最多可接收三條put消息
q.put("消息1") 
q.put("消息2")
print(q.full())  #False
q.put("消息3")
print(q.full()) #True

#因爲消息列隊已滿下面的try都會拋出異常，第一個try會等待2秒後再拋出異常，第二個Try會立刻拋出異常
try:
    q.put("消息4",True, 2)
except:
    print("消息列隊已滿，現有消息數量:%s"%q.qsize())

try:
    q.put_nowait("消息4")
except:
    print("消息列隊已滿，現有消息數量:%s"%q.qsize())

#推薦的方式，先判斷消息列隊是否已滿，再寫入
if not q.full():
    q.put_nowait("消息4")

#讀取消息時，先判斷消息列隊是否爲空，再讀取
if not q.empty():
    for i in range(q.qsize()):
        print(q.get_nowait())

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

• Queue.qsize()：返回當前隊列包含的消息數量；
• Queue.empty()：如果隊列爲空，返回True，反之False ；
• Queue.full()：如果隊列滿了，返回True,反之False；
• Queue.get([block[, timeout]])：獲取隊列中的一條消息，然後將其從列隊中移除，block默認值爲True；
  1）如果block使用默認值，且沒有設置timeout（單位秒），消息列隊如果爲空，此時程序將被阻塞（停在讀取狀態），直到從消息列隊讀到消息爲止，如果設置了timeout，則會等待timeout秒，若還沒讀取到任何消息，則拋出"Queue.Empty"異常；
  2）如果block值爲False，消息列隊如果爲空，則會立刻拋出"Queue.Empty"異常；
  -Queue.get_nowait()：相當Queue.get(False)；
• Queue.put(item,[block[, timeout]])：將item消息寫入隊列，block默認值爲True；
  1）如果block使用默認值，且沒有設置timeout（單位秒），消息列隊如果已經沒有空間可寫入，此時程序將被阻塞（停在寫入狀態），直到從消息列隊騰出空間爲止，如果設置了timeout，則會等待timeout秒，若還沒空間，則拋出"Queue.Full"異常；
  2）如果block值爲False，消息列隊如果沒有空間可寫入，則會立刻拋出"Queue.Full"異常；
• Queue.put_nowait(item)：相當Queue.put(item, False)；

2.2 Queue示例

以Queue爲例，在父進程中創建兩個子進程，一個往Queue裏寫數據，一個從Queue裏讀數據：

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


# 寫數據進程執行的代碼:
def write(q):
    for value in ['A', 'B', 'C']:
        print('Put %s to queue...' % value)
        q.put(value)
        time.sleep(random.random())

# 讀數據進程執行的代碼:
def read(q):
    while True:
        if not q.empty():
            value = q.get(True)
            print('Get %s from queue.' % value)
            time.sleep(random.random())
        else:
            break

if __name__=='__main__':
    # 父進程創建Queue，並傳給各個子進程：
    q = Queue()
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))
    # 啓動子進程pw，寫入:
    pw.start()    
    # 等待pw結束:
    pw.join()
    # 啓動子進程pr，讀取:
    pr.start()
    pr.join()
    # pr進程裏是死循環，無法等待其結束，只能強行終止:
    print('')
    print('所有數據都寫入並且讀完')

3. 進程池 Pool

當需要創建的子進程數量不多時，可以直接利用multiprocessing中的Process動態成生多個進程，但如果是上百甚至上千個目標，手動的去創建進程的工作量巨大，此時就可以用到multiprocessing模塊提供的Pool方法。

初始化Pool時，可以指定一個最大進程數，當有新的請求提交到Pool中時，如果池還沒有滿，那麼就會創建一個新的進程用來執行該請求；但如果池中的進程數已經達到指定的最大值，那麼該請求就會等待，直到池中有進程結束，纔會用之前的進程來執行新的任務，請看下面的實例：

# -*- coding:utf-8 -*-
from multiprocessing import Pool
import os, time, random

def worker(msg):
    t_start = time.time()
    print("%s開始執行,進程號爲%d" % (msg,os.getpid()))
    # random.random()隨機生成0~1之間的浮點數
    time.sleep(random.random()*2) 
    t_stop = time.time()
    print(msg,"執行完畢，耗時%0.2f" % (t_stop-t_start))

po = Pool(3)  # 定義一個進程池，最大進程數3
for i in range(0,10):
    # Pool().apply_async(要調用的目標,(傳遞給目標的參數元祖,))
    # 每次循環將會用空閒出來的子進程去調用目標
    po.apply_async(worker,(i,))

print("----start----")
po.close()  # 關閉進程池，關閉後po不再接收新的請求
po.join()  # 等待po中所有子進程執行完成，必須放在close語句之後
print("-----end-----")

# 官方推薦使用with 上下文管理器  等價於上
with Pool(5) as po:
	# 每個進程間傳入參數 不同
    print(po.map(worker, [i for i in range(10)]))
    # 每個進程間傳入參數 相同
    print(po.apply_async(worker, (11,))

multiprocessing.Pool常用函數解析：

• apply_async(func[, args[, kwds]]) ：使用非阻塞方式調用func（並行執行，堵塞方式必須等待上一個進程退出才能執行下一個進程），args爲傳遞給func的參數列表，kwds爲傳遞給func的關鍵字參數列表；
• close()：關閉Pool，使其不再接受新的任務；
• terminate()：不管任務是否完成，立即終止；
• join()：主進程阻塞，等待子進程的退出， 必須在close或terminate之後使用；

如果要使用Pool創建進程，就需要使用multiprocessing.Manager()中的Queue()，而不是multiprocessing.Queue()，否則會得到一條如下的錯誤信息：
RuntimeError: Queue objects should only be shared between processes through inheritance.
下面的實例演示了進程池中的進程如何通信：

# -*- coding:utf-8 -*-

# 修改import中的Queue爲Manager
import os, time, random
from multiprocessing import Manager,Pool


def reader(q):
    print("reader啓動(%s),父進程爲(%s)" % (os.getpid(), os.getppid()))
    for i in range(q.qsize()):
        print("reader從Queue獲取到消息：%s" % q.get(True))

def writer(q):
    print("writer啓動(%s),父進程爲(%s)" % (os.getpid(), os.getppid()))
    for i in "Python":
        q.put(i)

if __name__=="__main__":
    print("(%s) start" % os.getpid())
    q = Manager().Queue()  # 使用Manager中的Queue
    po = Pool()
    po.apply_async(writer, (q,))

    time.sleep(1)  # 先讓上面的任務向Queue存入數據，然後再讓下面的任務開始從中取數據

    po.apply_async(reader, (q,))
    po.close()
    po.join()
    print("(%s) End" % os.getpid())

4. 返回值接收

# -*- coding: utf-8 -*-
import os
from multiprocessing import Pool


def func_a(a):
	print(os.getpid())
	return a * 10


def func_b(a, b):
	print(os.getpid())
	return a * b
	

if __name__ == '__main__':
	# 方法一  推薦寫法
	with Pool(processes=5) as po:
		multiple_results = [pool.apply_async(func_a, (i,)) for i in range(4)]
        rst = [res.get(timeout=1) for res in multiple_results]
        print(rst)

	# 方法二
	rst = []
	test_list = [(1, 10), (2, 10)]
	with Pool(processes=5) as po:
		for i in test_list:
			res = pool.apply_async(func_b, i)
			rst.append(res.get(timeout=1000))  # 單位毫秒
	print(rst)	

5. 多進程案例 【文件夾複製】

import os
import time
import random
import multiprocessing


def copy_file(queue, file_name,source_folder_name,  dest_folder_name):
    """copy文件到指定的路徑"""
    f_read = open(source_folder_name + "/" + file_name, "rb")
    f_write = open(dest_folder_name + "/" + file_name, "wb")
    while True:
        time.sleep(random.random())
        content = f_read.read(1024)
        if content:
            f_write.write(content)
        else:
            break
    f_read.close()
    f_write.close()

    # 發送已經拷貝完畢的文件名字
    queue.put(file_name)


def main():
    # 獲取要複製的文件夾
    source_folder_name = input("請輸入要複製文件夾名字:")
    dest_folder_name = source_folder_name + "[副本]"

    # 創建目標文件夾
    try:
        os.mkdir(dest_folder_name)
    except:
        pass  # 如果文件夾已經存在，那麼創建會失敗

    # 獲取這個文件夾中所有的普通文件名
    file_names = os.listdir(source_folder_name)
    # 創建Queue
    queue = multiprocessing.Manager().Queue()
    # 創建進程池
    pool = multiprocessing.Pool(3)

    for file_name in file_names:
        # 向進程池中添加任務
        pool.apply_async(copy_file, args=(queue, file_name, source_folder_name, dest_folder_name))

    # 主進程顯示進度
    pool.close()

    all_file_num = len(file_names)
    while True:
        file_name = queue.get()
        if file_name in file_names:
            file_names.remove(file_name)

        copy_rate = (all_file_num-len(file_names))*100/all_file_num
        print("\r%.2f...(%s)" % (copy_rate, file_name) + " "*50, end="")
        if copy_rate >= 100:
            break
    print()


if __name__ == "__main__":
    main()