多进程

作者: 部落大圣 | 来源:发表于2020-03-29 00:18 被阅读0次

    Multiprocessing库里有Process

    守护进程

    在多进程中,同样存在守护进程的概念,如果一个进程被设置为守护进程,当父进程结束后,子进程会自动被终止,我们可以通过设置 daemon 属性来控制是否为守护进程。

    from multiprocessing import Process
    import time
    
    class MyProcess(Process):
        def __init__(self, loop):
            Process.__init__(self)
            self.loop = loop
    
    
        def run(self):
            for count in range(self.loop):
                time.sleep(1)
                print(f'pid: {self.pid} loopCount:{count}')
    
    if __name__ == '__main__':
        for i in range(2, 5):
            p = MyProcess(i)
            p.daemon = True
            p.start()
    
            print('Main Process is ended')
    

    因为主进程什么也没有做,所以输出

    print('Main Process is ended')
    

    这样做法就是不用担心主进程结束后避免子进程独立运行

    进程等待

    如果我们要子进程运行完毕才让主进程结束,这里就可以用join方法来实现进程等待

     for i in range(2, 5):
            p = MyProcess(i)
            precesses.append(p)
            p.daemon = True
            p.start()
        for p in precesses:
            p.join()
    

    join方法默认是无限期的,如果某一个子进程陷入死循环,主进程就会无限等待下去,解决的方法是给子进程指定一个最长的等待时长。例如我们输入1就是等待1秒。代码如下

     for i in range(2, 5):
            p = MyProcess(i)
            precesses.append(p)
            p.daemon = True
            p.start()
        for p in precesses:
            p.join(1)
    

    运行结果

    pid: 29136 loopCount:0
    pid: 43628 loopCount:0
    pid: 43328 loopCount:0
    pid: 29136 loopCount:1
    pid: 43628 loopCount:1
    pid: 43328 loopCount:1
    Main Process is ended
    

    终止进程

    当然,终止进程不止有守护进程这一种做法,我们也可以通过 terminate 方法来终止某个子进程,另外我们还可以通过 is_alive 方法判断进程是否还在运行。

    import multiprocessing
    import time
    
    def process():
        print('Starting')
        time.sleep(5)
        print('Finished')
    
    if __name__ == '__main__':
        p = multiprocessing.Process(target=process)
        print('Before:', p, p.is_alive())
    
        p.start()
        print('During:', p ,p.is_alive())
    
        p.terminate()
        print('Terminate:',p ,p.is_alive())
    
        p.join()
        print('Joined:', p ,p.is_alive())
    

    在上面的例子中,我们用Process创建了一个进程,接着调用start方法启动这个进程,然后调用terminate方法将进程终止,最后调用join方法。另外,在进程运行不同的阶我们还通过 is_alive 方法判断当前进程是否还在运行。
    运行结果

    Before: <Process(Process-1, initial)> False
    During: <Process(Process-1, started)> True
    Terminate: <Process(Process-1, started)> True
    Joined: <Process(Process-1, stopped[SIGTERM])> False
    

    这里有一个值得注意的地方,在调用terminate方法之后,我们用is_alive方法获取进程的状态发现依然还是运行状态。在调用join方法之后,is_alive方法获取进程的运行状态才变为终止状态。

    所以,在调用 terminate 方法之后,记得要调用一下 join 方法,这里调用 join 方法可以为进程提供时间来更新对象状态,用来反映出最终的进程终止效果。

    进程互斥锁

    相关文章

      网友评论

          本文标题:多进程

          本文链接:https://www.haomeiwen.com/subject/lqheuhtx.html