首页 / PYTHON / python 并发编程 多进程 Process对象的其他属性方法 join 方法

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

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了python 并发编程 多进程 Process对象的其他属性方法 join 方法，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含4442字，纯文字阅读大概需要7分钟。

内容图文

 

 

一 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())

‘‘‘
24880 is running,parent id is <25956>
24880 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()  只是给操作系统发送信号

 

 

jo in 会变串行？

 

        既然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 保证所有子进程执行完 主进程才能工作，不然一直阻塞

原文：https://www.cnblogs.com/mingerlcm/p/8987034.html

内容总结

以上是互联网集市为您收集整理的python 并发编程 多进程 Process对象的其他属性方法 join 方法全部内容，希望文章能够帮你解决python 并发编程 多进程 Process对象的其他属性方法 join 方法所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1180653.html

来源：【匿名】