Python多進程併發操做進程池Pool

目錄：

1. multiprocessing模塊
2. Pool類
3. apply
4. apply_async
5. map
6. close
7. terminate
8. join
9. 進程實例

multiprocessing模塊

若是你打算編寫多進程的服務程序，Unix/Linux無疑是正確的選擇。因爲Windows沒有fork調用，難道在Windows上沒法用Python編寫多進程的程序？因爲Python是跨平臺的，天然也應該提供一個跨平臺的多進程支持。multiprocessing模塊就是跨平臺版本的多進程模塊。multiprocessing模塊提供了一個Process類來表明一個進程對象，這個模塊表示像線程同樣管理進程，這個是multiprocessing的核心，它與threading很類似，對多核CPU的利用率會比threading好的多。

 看一下Process類的構造方法：

__init__(self, group=None, target=None, name=None, args=(), kwargs={})

參數說明： 
group：進程所屬組。基本不用 
target：表示調用對象。 
args：表示調用對象的位置參數元組。 
name：別名 
kwargs：表示調用對象的字典。

下面看一個簡單的例子

 1 #coding=utf-8
 2 import multiprocessing
 3 
 4 def do(n) :
 5   #獲取當前線程的名字
 6   name = multiprocessing.current_process().name
 7   print(name,'starting')
 8   print("worker ", n)
 9   return 
10 
11 if __name__ == '__main__' :
12   numList = []
13   for i in xrange(5) :
14     p = multiprocessing.Process(target=do, args=(i,))
15     numList.append(p)
16     p.start()
17     p.join()
18     print("Process end.")

運行結果

Process-1 starting
worker  0
Process end.
Process-2 starting
worker  1
Process end.
Process-3 starting
worker  2
Process end.
Process-4 starting
worker  3
Process end.
Process-5 starting
worker  4
Process end.

建立子進程時，只須要傳入一個執行函數和函數的參數，建立一個Process實例，並用其start()方法啓動，這樣建立進程比fork()還要簡單。 join()方法表示等待子進程結束之後再繼續往下運行，一般用於進程間的同步。

注意： 
在Windows上要想使用進程模塊，就必須把有關進程的代碼寫在當前.py文件的if __name__ == ‘__main__’ :語句的下面，才能正常使用Windows下的進程模塊。Unix/Linux下則不須要。

Pool類

 Pool類能夠提供指定數量的進程供用戶調用，當有新的請求提交到Pool中時，若是池尚未滿，就會建立一個新的進程來執行請求。若是池滿，請求就會告知先等待，直到池中有進程結束，纔會建立新的進程來執行這些請求。 
下面介紹一下multiprocessing 模塊下的Pool類下的幾個方法：

1.apply()

函數原型：apply(func[, args=()[, kwds={}]])

該函數用於傳遞不定參數，同python中的apply函數一致，主進程會被阻塞直到函數執行結束（不建議使用，而且3.x之後不在出現）。

2.apply_async

函數原型：apply_async(func[, args=()[, kwds={}[, callback=None]]])

與apply用法一致，但它是非阻塞的且支持結果返回後進行回調。

3.map()

 函數原型：map(func, iterable[, chunksize=None])

Pool類中的map方法，與內置的map函數用法行爲基本一致，它會使進程阻塞直到結果返回。 
注意：雖然第二個參數是一個迭代器，但在實際使用中，必須在整個隊列都就緒後，程序纔會運行子進程。

4.map_async()

函數原型：map_async(func, iterable[, chunksize[, callback]])
與map用法一致，可是它是非阻塞的。其有關事項見apply_async。

5.close()

關閉進程池（pool），使其不在接受新的任務。

6.terminal()

結束工做進程，不在處理未處理的任務。

7.join()

主進程阻塞等待子進程的退出， join方法要在close或terminate以後使用。

下面咱們看一個簡單的multiprocessing.Pool類的實例：

 1 # -*- coding: utf-8 -*-
 2 import time
 3 from multiprocessing import Pool
 4 def run(fn):
 5   #fn: 函數參數是數據列表的一個元素
 6   time.sleep(1)
 7   print(fn*fn)
 8 
 9 if __name__ == "__main__":
10   testFL = [1,2,3,4,5,6]
11   print ('shunxu:') #順序執行(也就是串行執行，單進程)
12   s = time.time()
13   for fn in testFL:
14     run(fn)
15   t1 = time.time()
16   print ("順序執行時間：", int(t1 - s))
17 
18   print ('concurrent:') #建立多個進程，並行執行
19   pool = Pool(10)  #建立擁有10個進程數量的進程池
20   #testFL:要處理的數據列表，run：處理testFL列表中數據的函數
21   pool.map(run, testFL)
22   pool.close()#關閉進程池，再也不接受新的進程
23   pool.join()#主進程阻塞等待子進程的退出
24   t2 = time.time()
25   print ("並行執行時間：", int(t2-t1))

輸出結果爲：

shunxu:
1
4
9
16
25
36
順序執行時間： 6
concurrent:
1
4
9
16
25
36
並行執行時間： 1

上例是一個建立多個進程併發處理與順序執行處理同一數據，所用時間的差異。從結果能夠看出，併發執行的時間明顯比順序執行要快不少，可是進程是要耗資源的，因此平時工做中，進程數也不能開太大。 對Pool對象調用join()方法會等待全部子進程執行完畢，調用join()以前必須先調用close()，讓其再也不接受新的Process了。

更多有關進程介紹請參考官方文檔：https://docs.python.org/2/library/multiprocessing.html

本文參考：http://blog.csdn.net/seetheworld518/article/details/49639651#t0

 

下次咱們運用多進程爬取趕集網數據。