Process 开启子进程 的两种方式、join控制子进程、守护进程

一、join控制子进程的一种方式

　　当主进程需要在子进程结束之后结束时，我们需要用到join来控制子进程。

import time
import random
from multiprocessing import Process
def func(index):
    time.sleep(random.random())
    print('第%s个邮件已经发送完毕'%index)
if __name__ == '__main__':
    p_list = []
    for i in range(10):
        p = Process(target= func,args=(i,))
        p.start()
        p_list.append(p)
    for p in p_list:
        p.join()        # 阻塞  直到p进程执行完毕就结束阻塞
    print('10个邮件已经发送完成')

10个发邮件的子进程是同时创建的，但是是随机分批次执行的，两个for循环几乎是同时进行的，一边执行，一边发送。

二、join控制子进程的一种方式

　　当我们需要一面向对象编程时

import os
from multiprocessing import Process
class MyProcess(Process):
    def __init__(self,arg):
        super().__init__()    # 调用父类的__init__方法
        self.arg = arg
    def run(self):
        print('子进程',os.getpid(),os.getppid(),self.arg)
if __name__ == '__main__':
    for i in range(10):
        p = MyProcess('参数')
        p.start()   # 开启一个子进程，让这个子进程执行run方法
        # p.join()
        print('主进程：',os.getpid())

三、守护进程

import time
from multiprocessing import Process
def func():
    print('子进程 start')
    time.sleep(3)
    print('子进程 end')
if __name__ == '__main__':
    p = Process(target= func)
    p.daemon = True   # 设置p为一个守护进程，必须在start之前完成
    p.start()
    time.sleep(2)
    print('主进程')

1、通过daemon给主进程设置一个守护进程。必须在start之前完成

2、守护进程会随着主进程的代码执行完毕而结束

import time
from multiprocessing import Process
def func1():
    count = 1
    while True:
        time.sleep(0.5)
        print(count*'*')
        count +=1
def func2():
    print('func2 start')
    time.sleep(5)
    print('func2 end')
if __name__ == '__main__':
    p1 = Process(target=func1)
    p1.daemon = True
    p1.start()
    Process(target=func2).start()
    time.sleep(3)
    print('主程序')

结果为：

func2 start
*
**
***
****
*****
主程序
func2 end

如果主进程代码已经执行完毕，但是子进程还没有执行完，守护进程不会继续执行
守护进程会随着主进程的代码执行结束而结束
主进程会等待子进程结束，守护进程只等待主进程代码结束就结束了