python并發(fā)編程 Process對象的其他屬性方法join方法詳解

更新時間：2019年08月20日 14:10:42 作者：minger_lcm

這篇文章主要介紹了python并發(fā)編程 Process對象的其他屬性方法join方法詳解,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

一 Process對象的join方法

在主進程運行過程中如果想并發(fā)地執(zhí)行其他的任務，我們可以開啟子進程，此時主進程的任務與子進程的任務分兩種情況

情況一：

在主進程的任務與子進程的任務彼此獨立的情況下，主進程的任務先執(zhí)行完畢后，主進程還需要等待子進程執(zhí)行完畢，然后統(tǒng)一回收資源。這種是沒有join方法

情況二：

如果主進程的任務在執(zhí)行到某一個階段時，需要等待子進程執(zhí)行完畢后才能繼續(xù)執(zhí)行，

就需要有一種機制能夠讓主進程檢測子進程是否運行完畢，在子進程執(zhí)行完畢后才繼續(xù)執(zhí)行，否則一直在原地阻塞，這就是join方法的作用

讓主進程等著，所有子進程執(zhí)行完畢后，主進程才繼續(xù)執(zhí)行

from multiprocessing import Process
import time
import os
def task():
  print("%s is running,parent id is <%s>" % (os.getpid(), os.getppid()))
  time.sleep(3)
  print("%s is done,parent id is <%s>" % (os.getpid(), os.getppid()))
if __name__ == "__main__":
  t = Process(target=task, )
  t.start()
  t.join()
  # 主進程 等子進程執(zhí)行完了
  print("主", os.getpid(), os.getppid())
'''
is running,parent id is <25956>
is done,parent id is <25956>
主 25956 2992
'''

子進程運行完，最后打印主進程，主進程結束了所有僵尸進程都會回收

開啟多個字進程向操作系統(tǒng)發(fā)送信號，但操作系統(tǒng)要處理的任務太多了，先開啟哪個子進程是隨機的，有時候可能先開啟主進程先，

操作系統(tǒng)什么時候開，開多長時間，我們是不知道的

from multiprocessing import Process
import time
import os
def task(name):
  print('%s is running' %name)
  time.sleep(2)
  print('%s is end' %name)
if __name__ == '__main__':
  p1 = Process(target=task, args=('子進程1',))
  p2 = Process(target=task, args=('子進程2',))
  p3 = Process(target=task, args=('子進程3',))
  p4 = Process(target=task, args=('子進程4',))
  p1.start()
  p2.start()
  p3.start()
  p4.start()
  print('主',os.getpid(),os.getppid())
'''
子進程1 is running
子進程2 is running
主 9268 5236
子進程3 is running
子進程4 is running
子進程1 is end
子進程2 is end
子進程3 is end
子進程4 is end

'''

也有可能這樣，先開啟主進程，

主 9556 5236
子進程1 is running
子進程3 is running
子進程2 is running
子進程4 is running
子進程1 is end
子進程3 is end
子進程2 is end
子進程4 is end

p.start() 只是給操作系統(tǒng)發(fā)送信號

join 會變串行？

既然join是等待進程結束, 那么我像下面這樣寫, 進程不就又變成串行的了嗎?
當然不是了, 必須明確：p.join()是讓誰等？
很明顯p.join()是讓主線程等待p 子進程的結束，卡住的是主進程而絕非子進程p，

from multiprocessing import Process
import time
import os
def task(name):
  print('%s is running' %(name))
  time.sleep(2)
  print('%s is end' %(name))
if __name__ == '__main__':
  p1 = Process(target=task, args=('子進程1',))
  p2 = Process(target=task, args=('子進程2',))
  p3 = Process(target=task, args=('子進程3',))
  p4 = Process(target=task, args=('子進程4',))
  p1.start()
  p2.start()
  p3.start()
  p4.start()
  p1.join()
  p2.join()
  p3.join()
  p4.join()
  print('主',os.getpid(),os.getppid())

詳細解析如下：

進程只要start就會在開始運行了,所以p1-p4.start()時,系統(tǒng)中已經有四個并發(fā)的進程了

而我們p1.join()是在等p1結束,沒錯p1只要不結束主線程就會一直卡在原地,這也是問題的關鍵

join是讓主線程等,而p1-p4仍然是并發(fā)執(zhí)行的,p1.join的時候,其余p2,p3,p4仍然在運行,等#p1.join結束,可能p2,p3,p4早已經結束了,這樣p2.join,p3.join.p4.join直接通過檢測，無需等待

所以4個join花費的總時間仍然是耗費時間最長的那個進程運行的時間

所以不會是串行執(zhí)行，是并發(fā)執(zhí)行

4個join花費的總時間仍然是耗費時間最長的那個進程運行的時間

所以就是5秒，就是子進程1 那個等待的時間

from multiprocessing import Process
import time
import os
def task(name,n):
  print('%s is running' %(name))
  time.sleep(n)
  print('%s is end' %(name))
if __name__ == '__main__':
  start = time.time()
  p1 = Process(target=task, args=('子進程1',5))
  p2 = Process(target=task, args=('子進程2',2))
  p3 = Process(target=task, args=('子進程3',2))
  p4 = Process(target=task, args=('子進程4',2))
  p1.start()
  p2.start()
  p3.start()
  p4.start()
  p1.join()
  p2.join()
  p3.join()
  p4.join()
  print('主',time.time() - start)
'''
子進程1 is running
子進程2 is running
子進程3 is running
子進程4 is running
子進程2 is end
子進程3 is end
子進程4 is end
子進程1 is end
主 5.413309812545776
'''

這種方式就是串行

等子進程1執(zhí)行時候，子進程2就沒有發(fā)送信號，要等子進程1 執(zhí)行完，再子進程2發(fā)送信號，開啟子進程2再執(zhí)行，按照這樣的順序

from multiprocessing import Process
import time
import os
def task(name,n):
  print('%s is running' %(name))
  time.sleep(n)
  print('%s is end' %(name))
if __name__ == '__main__':
  start = time.time()
  p1 = Process(target=task, args=('子進程1',5))
  p2 = Process(target=task, args=('子進程2',2))
  p3 = Process(target=task, args=('子進程3',2))
  p4 = Process(target=task, args=('子進程4',2))
  p1.start()
  p1.join()
  p2.start()
  p2.join()
  p3.start()
  p3.join()  
  p4.start()
  p4.join()
  print('主',time.time() - start)
'''
子進程1 is running
子進程1 is end
子進程2 is running
子進程2 is end
子進程3 is running
子進程3 is end
子進程4 is running
子進程4 is end
主 12.212698698043823

'''

上述啟動進程與 join進程可以簡寫為以下

from multiprocessing import Process
import time
import os
def task(name,n):
  print('%s is running' %(name))
  time.sleep(n)
  print('%s is end' %(name))
if __name__ == '__main__':
  start = time.time()
  p1 = Process(target=task, args=('子進程1',5))
  p2 = Process(target=task, args=('子進程2',2))
  p3 = Process(target=task, args=('子進程3',2))
  p4 = Process(target=task, args=('子進程4',2))
  process_list = [p1,p2,p3,p4]
  for p in process_list:
    p.start()
  for p in process_list:
    p.join()
  print('主',time.time() - start)

join 保證所有子進程執(zhí)行完主進程才能工作，不然一直阻塞

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持腳本之家。

您可能感興趣的文章: