python process join_python 并发编程 多进程 Process对象的其他属性方法 join 方法

一 Process对象的join方法

在主进程运行过程中如果想并发地执行其他的任务，我们可以开启子进程，此时主进程的任务与子进程的任务分两种情况

情况一：

在主进程的任务与子进程的任务彼此独立的情况下，主进程的任务先执行完毕后，主进程还需要等待子进程执行完毕，然后统一回收资源。 这种是没有join方法

情况二：

如果主进程的任务在执行到某一个阶段时，需要等待子进程执行完毕后才能继续执行，

就需要有一种机制能够让主进程检测子进程是否运行完毕，在子进程执行完毕后才继续执行，否则一直在原地阻塞，这就是join方法的作用

让主进程等着，所有子进程执行完毕后，主进程才继续执行

from multiprocessing importProcessimporttimeimportosdeftask():print("%s is running,parent id is " %(os.getpid(), os.getppid()))

time.sleep(3)print("%s is done,parent id is " %(os.getpid(), os.getppid()))if __name__ == "__main__":

t= Process(target=task, )

t.start()

t.join()#主进程 等子进程执行完了

print("主", os.getpid(), os.getppid())'''24880 is running,parent id is <25956>

24880 is done,parent id is <25956>

主 25956 2992'''

子进程运行完，最后打印主进程，主进程结束了 所有僵尸进程都会回收

开启多个字进程 向操作系统发送信号，但操作系统要处理的任务太多了，先开启 哪个子进程是随机的，有时候可能先开启主进程先，

操作系统什么时候开，开多长时间，我们是不知道的

from multiprocessing importProcessimporttimeimportosdeftask(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子进程1isrunning

子进程3isrunning

子进程2isrunning

子进程4isrunning

子进程1isend

子进程3isend

子进程2isend

子进程4is end

p.start()  只是给操作系统发送信号

join 会变串行？

既然join是等待进程结束, 那么我像下面这样写, 进程不就又变成串行的了吗?

当然不是了, 必须明确：p.join()是让谁等？

很明显p.join()是让主线程等待p 子进程的结束，卡住的是主进程而绝非 子进程p，

from multiprocessing importProcessimporttimeimportosdeftask(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 importProcessimporttimeimportosdeftask(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 importProcessimporttimeimportosdeftask(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 importProcessimporttimeimportosdeftask(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 inprocess_list:

p.start()for p inprocess_list:

p.join()print('主',time.time() - start)

join 保证所有子进程执行完 主进程才能工作，不然一直阻塞