python中Process對象之join方法的示例分析

這篇文章主要為大家展示了“python中Process對象之join方法的示例分析”，內容簡而易懂，條理清晰，希望能夠幫助大家解決疑惑，下面讓小編帶領大家一起研究并學習一下“python中Process對象之join方法的示例分析”這篇文章吧。

一 Process對象的join方法

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

情況一：

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

情況二：

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

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

讓主進程等著，所有子進程執行完畢后，主進程才繼續執行

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()
  # 主進程 等子進程執行完了
  print("主", os.getpid(), os.getppid())
'''
is running,parent id is <25956>
is done,parent id is <25956>
主 25956 2992
'''

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

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

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

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() 只是給操作系統發送信號

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()時,系統中已經有四個并發的進程了

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

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

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

所以不會是串行執行，是并發執行

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執行時候，子進程2就沒有發送信號，要等子進程1 執行完，再子進程2發送信號 ，開啟子進程2再執行，按照這樣的順序

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 保證所有子進程執行完 主進程才能工作，不然一直阻塞

以上是“python中Process對象之join方法的示例分析”這篇文章的所有內容，感謝各位的閱讀！相信大家都有了一定的了解，希望分享的內容對大家有所幫助，如果還想學習更多知識，歡迎關注億速云行業資訊頻道！