轉載自：

Python3.2帶來了 concurrent.futures 模組，這個模組具有執行緒池和程序池、管理並行程式設計任務、處理非確定性的執行流程、程序/執行緒同步等功能。

此模組由以下部分組成：

• concurrent.futures.Executor: 這是一個虛擬基類，提供了非同步執行的方法。
• submit(function, argument): 排程函式（可呼叫的物件）的執行，將 argument 作為引數傳入。
• map(function, argument): 將 argument 作為引數執行函式，以 非同步 的方式。
• shutdown(Wait=True): 發出讓執行者釋放所有資源的訊號。
• concurrent.futures.Future: 其中包括函式的非同步執行。Future物件是submit任務（即帶有引數的functions）到executor的例項。

Executor是抽象類，可以通過子類訪問，即執行緒或程序的 ExecutorPools 。因為，執行緒或程序的例項是依賴於資源的任務，所以最好以“池”的形式將他們組織在一起，作為可以重用的launcher或executor。

2.1. 使用執行緒池和程序池

執行緒池或程序池是用於在程式中優化和簡化執行緒/程序的使用。通過池，你可以提交任務給executor。池由兩部分組成，一部分是內部的佇列，存放著待執行的任務；另一部分是一系列的程序或執行緒，用於執行這些任務。池的概念主要目的是為了重用：讓執行緒或程序在生命週期內可以多次使用。它減少了建立建立執行緒和程序的開銷，提高了程式效能。重用不是必須的規則，但它是程式設計師在應用中使用池的主要原因。

2.2. 準備工作

current.Futures 模組提供了兩種 Executor 的子類，各自獨立操作一個執行緒池和一個程序池。這兩個子類分別是：

• concurrent.futures.ThreadPoolExecutor(max_workers)
• concurrent.futures.ProcessPoolExecutor(max_workers)

max_workers 引數表示最多有多少個worker並行執行任務。

2.3. 如何做…

下面的示例程式碼展示了執行緒池和程序池的功能。這裡的任務是，給一個list number_list ，包含1到10。對list中的每一個數字，乘以1+2+3…+10000000的和（這個任務只是為了消耗時間）。

下面的程式碼分別測試了：

• 順序執行
• 通過有5個worker的執行緒池執行
• 通過有5個worker的程序池執行

（譯者注：原文的程式碼是錯誤的，這裡貼出的程式碼以及執行結果是修改後的，詳見： 關於第四章第2節書中程式的疑問 #16 ，感謝 @Microndgt 提出） 程式碼如下：:

import concurrent.futures
import time
number_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

def evaluate_item(x):
        # 計算總和，這裡只是為了消耗時間
        result_item = count(x)
        # 列印輸入和輸出結果
        return result_item

def  count(number) :
        for i in range(0, 10000000):
                i=i+1
        return i * number

if __name__ == "__main__":
        # 順序執行
        start_time = time.time()
        for item in number_list:
                print(evaluate_item(item))
        print("Sequential execution in " + str(time.time() - start_time), "seconds")
        # 執行緒池執行
        start_time_1 = time.time()
        with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
                futures = [executor.submit(evaluate_item, item) for item in number_list]
                for future in concurrent.futures.as_completed(futures):
                        print(future.result())
        print ("Thread pool execution in " + str(time.time() - start_time_1), "seconds")
        # 程序池
        start_time_2 = time.time()
        with concurrent.futures.ProcessPoolExecutor(max_workers=5) as executor:
                futures = [executor.submit(evaluate_item, item) for item in number_list]
                for future in concurrent.futures.as_completed(futures):
                        print(future.result())
        print ("Process pool execution in " + str(time.time() - start_time_2), "seconds")

執行這個程式碼，我們可以看到執行時間的輸出：:

$ python3 pool.py
10000000
20000000
30000000
40000000
50000000
60000000
70000000
80000000
90000000
100000000
Sequential execution in 7.936585903167725 seconds
10000000
30000000
40000000
20000000
50000000
70000000
90000000
100000000
80000000
60000000
Thread pool execution in 7.633088827133179 seconds
40000000
50000000
10000000
30000000
20000000
70000000
90000000
60000000
80000000
100000000
Process pool execution in 4.787093639373779 seconds

2.4. 討論

我們建立了一個list存放10個數字，然後使用一個迴圈計算從1加到10000000，打印出和與 number_list 的乘積。:

def evaluate_item(x):
    # 計算總和，這裡只是為了消耗時間
    result_item = count(x)
    # 列印輸入和輸出結果
    print ("item " + str(x) + " result " + str(result_item))

def  count(number) :
    for i in range(0, 10000000):
        i=i+1
    return i * number

在主要程式中，我們先使用順序執行跑了一次程式：:

if __name__ == "__main__":
    # 順序執行
    start_time = time.clock()
    for item in number_list:
        evaluate_item(item)
    print("Sequential execution in " + str(time.clock() - start_time), "seconds")

然後，我們使用了 futures.ThreadPoolExecutor 模組的執行緒池跑了一次：:

with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
    for item in number_list:
        executor.submit(evaluate_item,  item)
print ("Thread pool execution in " + str(time.clock() - start_time_1), "seconds")

ThreadPoolExecutor 使用執行緒池中的一個執行緒執行給定的任務。池中一共有5個執行緒，每一個執行緒從池中取得一個任務然後執行它。當任務執行完成，再從池中拿到另一個任務。

當所有的任務執行完成後，打印出執行用的時間：:

print ("Thread pool execution in " + str(time.clock() - start_time_1), "seconds")

最後，我們又用 ProcessPoolExecutor 跑了一次程式：:

with concurrent.futures.ProcessPoolExecutor(max_workers=5) as executor:
    for item in number_list:
        executor.submit(evaluate_item,  item)

如同 ThreadPoolExecutor 一樣， ProcessPoolExecutor 是一個executor，使用一個執行緒池來並行執行任務。然而，和 ThreadPoolExecutor 不同的是， ProcessPoolExecutor 使用了多核處理的模組，讓我們可以不受GIL的限制，大大縮短執行時間。