問題起因

最近要將一個文字分割成好幾個topic，每個topic設計一個regressor，各regressor是相互獨立的，最後彙總所有topic的regressor得到總得預測結果。沒錯！類似bagging ensemble！只是我沒有抽樣。文字不大，大概3000行，topic個數為8，於是我寫了一個序列的程式，一個topic算完之後再算另一個topic。可是我在每個topic中用了GridSearchCV來調參，又要選特徵又要調整regressor的引數，導致引數組合一共有1782種。我真是低估了調參的時間，程式跑了一天一夜最後因為忘記import一個庫導致最終的預測精度沒有算出來。後來想到，既然每個topic的預測都是獨立的，那是不是可以並行呢？

Python中的多執行緒與多程序

但是聽聞Python的多執行緒實際上並不能真正利用多核，所以如果使用多執行緒實際上還是在一個核上做併發處理。不過，如果使用多程序就可以真正利用多核，因為各程序之間是相互獨立的，不共享資源，可以在不同的核上執行不同的程序，達到並行的效果。同時在我的問題中，各topic相互獨立，不涉及程序間的通訊，只需最後彙總結果，因此使用多程序是個不錯的選擇。

multiprocessing

一個子程序

multiprocessing模組提供process類實現新建程序。下述程式碼是新建一個子程序。

from multiprocessing import Process

def f(name)
 
:
    print 'hello', name

if __name__ == '__main__':
    p = Process(target=f, args=('bob',)) # 新建一個子程序p，目標函式是f，args是函式f的引數列表
    p.start() # 開始執行程序
    p.join() # 等待子程序結束

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

上述程式碼中p.join()的意思是等待子程序結束後才執行後續的操作，一般用於程序間通訊。例如有一個讀程序pw和一個寫程序pr，在呼叫pw之前需要先寫pr.join()，表示等待寫程序結束之後才開始執行讀程序。

多個子程序

如果要同時建立多個子程序可以使用multiprocessing.Pool

import multiprocessing
import time

def func(msg):
    print multiprocessing.current_process().name + '-' + msg

if __name__ == "__main__":
    pool = multiprocessing.Pool(processes=4) # 建立4個程序
    for i in xrange(10):
        msg = "hello %d" %(i)
        pool.apply_async(func, (msg, ))
    pool.close() # 關閉程序池，表示不能在往程序池中新增程序
    pool.join() # 等待程序池中的所有程序執行完畢，必須在close()之後呼叫
    print "Sub-process(es) done."

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

輸出結果如下：

Sub-process(es) done.
PoolWorker-34-hello 1
PoolWorker-33-hello 0
PoolWorker-35-hello 2
PoolWorker-36-hello 3
PoolWorker-34-hello 7
PoolWorker-33-hello 4
PoolWorker-35-hello 5
PoolWorker-36-hello 6
PoolWorker-33-hello 8
PoolWorker-36-hello 9

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

上述程式碼中的pool.apply_async()是apply()函式的變體，apply_async()是apply()的並行版本，apply()是apply_async()的阻塞版本，使用apply()主程序會被阻塞直到函式執行結束，所以說是阻塞版本。apply()既是Pool的方法，也是Python內建的函式，兩者等價。可以看到輸出結果並不是按照程式碼for迴圈中的順序輸出的。

多個子程序並返回值

apply_async()本身就可以返回被程序呼叫的函式的返回值。上一個建立多個子程序的程式碼中，如果在函式func中返回一個值，那麼pool.apply_async(func, (msg, ))的結果就是返回pool中所有程序的值的物件（注意是物件，不是值本身）。

import multiprocessing
import time

def func(msg):
    return multiprocessing.current_process().name + '-' + msg

if __name__ == "__main__":
    pool = multiprocessing.Pool(processes=4) # 建立4個程序
    results = []
    for i in xrange(10):
        msg = "hello %d" %(i)
        results.append(pool.apply_async(func, (msg, )))
    pool.close() # 關閉程序池，表示不能再往程序池中新增程序，需要在join之前呼叫
    pool.join() # 等待程序池中的所有程序執行完畢
    print ("Sub-process(es) done.")

    for res in results:
        print (res.get())

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18

上述程式碼輸出結果如下：

Sub-process(es) done.
PoolWorker-37-hello 0
PoolWorker-38-hello 1
PoolWorker-39-hello 2
PoolWorker-40-hello 3
PoolWorker-37-hello 4
PoolWorker-38-hello 5
PoolWorker-39-hello 6
PoolWorker-37-hello 7
PoolWorker-40-hello 8
PoolWorker-38-hello 9

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

與之前的輸出不同，這次的輸出是有序的。

如果電腦是八核，建立8個程序，在Ubuntu下輸入top命令再按下大鍵盤的1，可以看到每個CPU的使用率是比較平均的，如下圖：

在system monitor中也可以清楚看到執行多程序前後CPU使用率曲線的差異。 

轉自：https://blog.csdn.net/jinping_shi/article/details/52433867