多进程

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 方法可以为进程提供时间来更新对象状态，用来反映出最终的进程终止效果。

进程互斥锁