多進程multiprocessing模塊

multiprocessing是python的多進程管理包，和threading.Thread相似。直接從側面用subprocesses替換線程使用GIL的方式，因爲這一點，multiprocessing模塊能夠讓程序員在給定的機器上充分的利用CPU。

在multiprocessing中，經過建立Process對象生成進程，而後調用它的start()方法

1 from multiprocessing import Process
2 
3 def f(name):
4     print('hello', name)
5 
6 if __name__ == '__main__':
7     p = Process(target=f, args=('bob',))
8     p.start()
9     p.join()

和線程的方法都差很少

 daemon:

      daemon = True  不等待子線程完事就返回     

join:

     join(timeout=3)     等待線程3秒，超時後繼續執行代碼

 1 #-*- coding:utf-8 -*-
 2 from multiprocessing import Process
 3 import time
 4 def f(name):
 5     time.sleep(2)
 6     print('hello', name)
 7 
 8 if __name__ == '__main__':
 9     p = Process(target=f, args=('p',))
10     #默認Flase 等待子線程執行完畢，TRUE 不等待子線程完事
11     #p.daemon = True
12     p.start()
13     p1 = Process(target=f, args=('p1',))
14     p1.start()
15 
16     #等待3秒超時，超時事後才能繼續執行
17     p1.join(timeout=3)
18 
19     print("end")

示例

 

進程間的數據操做

 1 #-*- coding:utf-8 -*-
 2 from multiprocessing import Process
 3 import time
 4 
 5 li = []
 6 
 7 def foo(i):
 8     li.append(i)
 9     #查看進程中的li列表
10     print("li:",li)
11 
12 
13 
14 if __name__ == '__main__' :
15  for i in range(10):
16      p = Process(target=foo,args=(i,))
17      p.start()
18  '''結果：
19  ('li:', [1])
20 ('li:', [3])
21 ('li:', [0])
22 ('li:', [4])
23 ('li:', [6])
24 ('li:', [2])
25 ('li:', [5])
26 ('li:', [9])
27 ('li:', [7])
28 ('li:', [8])
29  '''

View Code

進程間默認是沒法通訊的，若是向通訊就通訊 安全就徹底沒法保證

 

 

進程池

進程池內部維護一個進程序列，當使用時，則去進程池中獲取一個進程，若是進程池序列中沒有可供使用的進進程，那麼程序就會等待，直到進程池中有可用進程爲止。

進程池中有兩個方法：

• apply
• apply_async

 1 # -*- coding:utf-8 -*-
 2 from  multiprocessing import Process,Pool
 3 import time
 4 
 5 def Foo(i):
 6     time.sleep(1)
 7     print("Foo:%d"%i)
 8     return i+100
 9 
10 #Foo最後return 的值會傳遞到Bar的參數中。
11 def Bar(arg):
12     print("callback:%d"%arg)
13 
14 
15 
16 if __name__ == '__main__':
17     pool = Pool(5)
18     for i in range(10):
19         #同步執行了每一個進程都會join,也就是說串行執行等一個進程完畢後在執行下一個
20         #pool.apply(Foo,(i,))
21 
22         #異步執行,callback可選,執行完子進程後將return結果帶入到回調函數中。
23         pool.apply_async(func=Foo, args=(i,),callback=Bar)
24 
25         #get方法獲取異步執行函數的return結果
26         #print pool.apply_async(func =Foo, args=(i,)).get()
27     
28     pool.close()
29     #這個是對進程池操做,等待全部子進程完畢在關閉,若是註釋主程序將不會等完子進程完事在退出，而是直接退出
30     #執行這個方法以前必須執行pool.close()或 pool.terminate()關閉池
31     pool.join()

pool

pool下的join源碼：

1   def join(self):
2         debug('joining pool')
3         #狀態是CLOSE或TERMINATE
4         assert self._state in (CLOSE, TERMINATE)
5         self._worker_handler.join()
6         self._task_handler.join()
7         self._result_handler.join()
8         for p in self._pool:
9             p.join()

join