python多进程之join函数

join让主进程等待子进程结束之后，再执行主进程。
举例：

from multiprocessing import Process
import time
def task(name):
print(f"{name} is running")
time.sleep(2)
print(f"{name} is gone")
if __name__ == "__main__":
p = Process(target=task,args=("常辛",))
# 创建一个进程对象
p.start()
# p.join()
print(111)
print("主开始")
111
主开始
常辛 is running
常辛 is gone
from multiprocessing import Process
import time
def task(name):
print(f"{name} is running")
time.sleep(2)
print(f"{name} is gone")
if __name__ == "__main__":
p = Process(target=task,args=("常辛",))
# 创建一个进程对象
p.start()
p.join()
print(111)
print("主开始")
常辛 is running
常辛 is gone
111
主开始

一般而言，主程序中如果单为一句print，则优先执行print语句（如果执行语句够多，则可见子进程执行），给大家举个例子：

from multiprocessing import Process
import time
def task(name):
print(f"{name} is running")
time.sleep(2)
print(f"{name} is gone")
if __name__ == "__main__":
p = Process(target=task,args=("常辛",))
# 创建一个进程对象
p.start()
# p.join()
print(111)
time.sleep(0.5)
print("主开始")
111
常辛 is running
主开始
常辛 is gone

如果程序中有连续多个join函数，则只有最先的join是起作用的，举例如下（多个子进程使用join函数）：

from multiprocessing import Process
import time
def task(name,sec):
print(f"{name} is running")
time.sleep(sec)
print(f"{name} is gone")
if __name__ == "__main__":
start_time = time.time()
p = Process(target=task,args=("常",3))
# 创建一个进程对象
p1 = Process(target=task,args=("辛",2))
# 创建一个进程对象
p2 = Process(target=task,args=("王",5))
# 创建一个进程对象
p.start()
p1.start()
p2.start()
# join只针对主进程，如果join下面多次join他是不阻塞的
# p.join()
# p1.join()
# p2.join()
print(f"主{time.time()-start_time}")
# 0.02这只是主进程结束的时间
主0.019910097122192383
常 is running
辛 is running
王 is running
辛 is gone
常 is gone
王 is gone
from multiprocessing import Process
import time
def task(name,sec):
print(f"{name} is running")
time.sleep(sec)
print(f"{name} is gone")
if __name__ == "__main__":
start_time = time.time()
p = Process(target=task,args=("常",3))
# 创建一个进程对象
p1 = Process(target=task,args=("辛",2))
# 创建一个进程对象
p2 = Process(target=task,args=("王",5))
# 创建一个进程对象
p.start()
p1.start()
p2.start()
# join只针对主进程，如果join下面多次join他是不阻塞的
p.join()
p1.join()
p2.join()
print(f"主{time.time()-start_time}")
常 is running
辛 is running
王 is running
辛 is gone
常 is gone
王 is gone
主5.110209226608276
# 注：如果不是连续多个，比如这样：
from multiprocessing import Process
import time
def task(name,sec):
print(f"{name} is running")
time.sleep(sec)
print(f"{name} is gone")
if __name__ == "__main__":
start_time = time.time()
p = Process(target=task,args=("常",3))
# 创建一个进程对象
p1 = Process(target=task,args=("辛",2))
# 创建一个进程对象
p2 = Process(target=task,args=("王",5))
# 创建一个进程对象
p.start()
p.join()
p1.start()
p1.join()
p2.start()
p2.join()
print(f"主{time.time()-start_time}")
常 is running
常 is gone
辛 is running
辛 is gone
王 is running
王 is gone
主10.23875904083252
# 这样就会先执行p进程，再执行p1进程，再执行p2进程

这里如果我将p1、p2注释掉，则在p.join()执行完后，出了结果就会执行print(f"主{time.time()-start_time}")这句：

from multiprocessing import Process
import time
def task(name,sec):
print(f"{name} is running")
time.sleep(sec)
print(f"{name} is gone")
if __name__ == "__main__":
start_time = time.time()
p = Process(target=task,args=("常",3))
# 创建一个进程对象
p1 = Process(target=task,args=("辛",2))
# 创建一个进程对象
p2 = Process(target=task,args=("王",5))
# 创建一个进程对象
p.start()
p1.start()
p2.start()
# join只针对主进程，如果join下面多次join他是不阻塞的
p.join()
# p1.join()
# p2.join()
print(f"主{time.time()-start_time}")
常 is running
辛 is running
王 is running
辛 is gone
常 is gone
主3.0900182723999023
王 is gone

大家可能会有疑问，p1没有执行join，为什么也先print前面打印出来？
因为它执行时，time.sleep的时间比p的短，所以会比p先执行完，所以在p执行完之前打印时，也会先一步打印。
总结就是：join就是阻塞，主进程有join，主进程下面的代码一律不执行，直到进程执行完毕之后，再执行。

因为拿了多进程举例，这里讲下多进程有什么用？
举个例子，你烧水五分钟、煮饭十分钟、切菜五分钟，假如一步一步执行，则要花二十分钟，但是如果把水烧上，饭煮上，然后趁着这功夫切菜，最多只花十分钟，这给我们节约了时间。给大家举个例子：

from multiprocessing import Process
import time
def task(sec):
print(f"is running")
time.sleep(sec)
print(f"is gone")
if __name__ == "__main__":
start_time = time.time()
# 错误示范
for i in range(1,4):
p = Process(target=task, args=(i,))
# 创建一个进程对象
p.start()
p.join()
# 正确示范
# l1 = []
# for i in range(1, 4):
#
p = Process(target=task, args=(i,))
# 创建一个进程对象
#
l1.append(p)
#
p.start()
# for i in l1:
#
i.join()
print(f"主{time.time()-start_time}")
is running
is gone
is running
is gone
is running
is gone
主6.3900392055511475
这里程序要执行6秒多钟，修改一下
from multiprocessing import Process
import time
def task(sec):
print(f"is running")
time.sleep(sec)
print(f"is gone")
if __name__ == "__main__":
start_time = time.time()
# 错误示范
# for i in range(1,4):
#
p = Process(target=task, args=(i,))
# 创建一个进程对象
#
p.start()
#
p.join()
# 正确示范
l1 = []
for i in range(1, 4):
p = Process(target=task, args=(i,))
# 创建一个进程对象
l1.append(p)
p.start()
for i in l1:
i.join()
print(f"主{time.time()-start_time}")
is running
is running
is running
is gone
is gone
is gone
主3.099172592163086
则程序只需要执行三秒多钟，时间成本上节约了将近一半！

最后

以上就是故意悟空为你收集整理的python进程的join函数python多进程之join函数的全部内容，希望文章能够帮你解决python进程的join函数python多进程之join函数所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。