python多核處理器算力浪費問題解決

前言

我們都知道python因為其GIL鎖導致每一個執行緒被繫結到一個核上，導致python無法通過執行緒實現真正的平行計算。從而導致大量的核算力的浪費。但是

concurrent.futures模組，可以利用multiprocessing實現真正的平行計算。

但是在提高python的計算效能前，首先要明白自己的程式目前是什麼型別？ 對於不同型別的程式，如果安裝下述方法進行改造，可能效率並不會提高。

IO密集型：讀取檔案，讀取網路通訊端頻繁。

計算密集型：大量消耗CPU的數學與邏輯運算，也就是我們這裡說的平行計算。

IO密集型

可以使用asyncio 來進行優化，jit的原理是編譯為機器碼執行，但是io中可能會存在異常字元，所以也不推薦使用，當然在存在多型主機的情況下，可以採用分散式程式設計來提高效率，或者過concurrent.futures模組來實現。

詳情請看下一篇博文 python 效能的優化

計算密集型

當然我們可以使用jit,分散式程式設計，python 呼叫c程式設計來優化效能，但是要充分利用計算機的核數，可以通過concurrent.futures模組來實現,其在實現提高平行計算能力時時通過多程序實現。

該concurrent.futures模組提供了一個用於非同步執行callables的高階介面。

可以使用執行緒，使用ThreadPoolExecutor或單獨的程序 來執行非同步執行 ProcessPoolExecutor。兩者都實現相同的介面，由抽象Executor類定義。

concurrent.futures會以子程序的形式，平行的執行多個python直譯器，從而令python程式可以利用多核CPU來提升執行速度。由於子程序與主直譯器相分離，所以他們的全域性直譯器鎖也是相互獨立的。每個子程序都能夠完整的使用一個CPU核心。

def gcd(pair):
    a, b = pair
    low = min(a, b)
    for i in range(low, 0, -1):
        if a % i == 0 and b % i == 0:
            return i
numbers = [
    (1963309, 2265973), (1879675, 2493670), (2030677, 3814172),
    (1551645, 2229620), (1988912, 4736670), (2198964, 7876293)
]
import time
start = time.time()
results = list(map(gcd, numbers))
end = time.time()
print 'Took %.3f seconds.' % (end - start)
Took 2.507 seconds.

import time
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor, Executor
start = time.time()
pool = ProcessPoolExecutor(max_workers=2)
results = list(pool.map(gcd, numbers))
end = time.time()
print 'Took %.3f seconds.' % (end - start)
Took 1.861 seconds.

在兩個CPU核心的機器上執行多程序程式，比其他兩個版本都快。這是因為，ProcessPoolExecutor類會利用multiprocessing模組所提供的底層機制，完成下列操作：

1）把numbers列表中的每一項輸入資料都傳給map。

2）用pickle模組對資料進行序列化，將其變成二進位制形式。

3）通過本地通訊端，將序列化之後的資料從煮直譯器所在的程序，傳送到子直譯器所在的程序。

4）在子程序中，用pickle對二進位制資料進行反序列化，將其還原成python物件。

5）引入包含gcd函數的python模組。

6）各個子程序並行的對各自的輸入資料進行計算。

7）對執行的結果進行序列化操作，將其轉變成位元組。

8）將這些位元組通過socket複製到主程序之中。

9）主程序對這些位元組執行反序列化操作，將其還原成python物件。

10）最後，把每個子程序所求出的計算結果合併到一份列表之中，並返回給呼叫者。

multiprocessing開銷比較大，原因就在於：主程序和子程序之間通訊，必須進行序列化和反序列化的操作。

submit（fn，* args，** kwargs ） 將可呼叫的fn排程為執行， 並返回表示可呼叫執行的物件。

fn(*args **kwargs)Future
with ThreadPoolExecutor(max_workers=1) as executor:
    future = executor.submit(pow, 323, 1235)
    print(future.result())
map（func，* iterables，timeout = None，chunksize = 1 ）

與以下類似：map(func, *iterables)

在iterables收集立即而不是懶洋洋地; func以非同步方式執行，並且可以同時對func進行多次呼叫 。 返回的迭代器引發一個concurrent.futures.TimeoutError if next()被呼叫，並且在從原始呼叫到超時秒後結果不可用Executor.map()。 timeout可以是int或float。如果未指定 超時None，則等待時間沒有限制。

如果func呼叫引發異常，則在從迭代器檢索其值時將引發該異常。

使用時ProcessPoolExecutor，此方法將iterables切割 為多個塊，並將其作為單獨的任務提交給池。可以通過將chunksize設定為正整數來指定這些塊的（近似）大小。對於很長的iterables，採用大值CHUNKSIZE可以顯著改善效能相比的1.預設大小 ThreadPoolExecutor，CHUNKSIZE沒有效果。

在3.5版中更改：新增了chunksize引數。

shutdown（wait = True ） 向執行者發出訊號，表示當目前待處理的期貨執行完畢時，它應該釋放它正在使用的任何資源。關機後撥打電話Executor.submit()和撥打電話 Executor.map()將會提出RuntimeError。

如果等待是True那麼這種方法將不會返回，直到所有懸而未決的期貨執行完畢，並與執行相關的資源已被釋放。如果等待，False那麼此方法將立即返回，並且當執行所有未決期貨時，將釋放與執行程式關聯的資源。無論wait的值如何，整個Python程式都不會退出，直到所有待處理的期貨都執行完畢。

如果使用with語句，則可以避免必須顯式呼叫此方法 ，該語句將關閉Executor （等待，就像Executor.shutdown()使用wait set 呼叫一樣True）：

import shutil
with ThreadPoolExecutor(max_workers=4) as e:
    e.submit(shutil.copy, 'src1.txt', 'dest1.txt')
    e.submit(shutil.copy, 'src2.txt', 'dest2.txt')
    e.submit(shutil.copy, 'src3.txt', 'dest3.txt')
    e.submit(shutil.copy, 'src4.txt', 'dest4.txt')

以上就是python多核處理器算力浪費現象處理的詳細內容，更多關於python多核處理器算力浪費的資料請關注it145.com其它相關文章！