[TOC]
# **多进程和守护进程**
## 一 **multiprocessing模块介绍**
python中的多线程无法利用多核优势，如果想要充分地使用多核CPU的资源(os.cpu_count()查看)，在python中大部分情况需要使用多进程。
Python提供了multiprocessing。 multiprocessing模块用来开启子进程，并在子进程中执行我们定制的任务(比如函数)，该模块与多线程模块threading的编程接口类似。
multiprocessing模块的功能众多：支持子进程、通信和共享数据、执行不同形式的同步，>提供了Process、Queue、Pipe、Lock等组件。
>与线程不同，进程没有任何共享状态，进程修改的数据，改动仅限于该进程内。
## 二 **Process类的介绍**
**Process类是用来创建进程的类**：由该类实例化得到的对象，可用来开启一个子进程
### **语法**
~~~
Process([group [, target [, name [, args [, kwargs]]]]])
强调：
1. 需要使用关键字的方式来指定参数
2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号
~~~
### **参数介绍：**
~~~
group参数未使用，值始终为None
target表示调用对象，即子进程要执行的任务
args表示调用对象的位置参数元组，args=(1,2,'egon',)
kwargs表示调用对象的字典,kwargs={'name':'egon','age':18}
name为子进程的名称
~~~
### **方法介绍：**
~~~
p.start()：启动进程
p.terminate():强制终止进程p，可能产生僵尸进程和死锁
p.is_alive():判断子进程p是否仍然运行，返回True
p.join([timeout]):主线程阻塞,等待子进程p终止后再继续,timeout可选。
~~~
### **属性介绍：**
~~~
p.daemon：让子进程以守护进程方式运行,必须在p.start()之前设置
p.name:获取子进程的名称
p.pid：获取子进程的pid
~~~
## **三 Process类的使用**
python用multiprocessing创建多进程有两种方式,一种是使用`Process`类直接创建,一种是继承`Process`类创建自己的类来使用
**注意：在windows中Process()必须放到# if \_\_name\_\_ == '\_\_main\_\_':下**
### **创建并开启子进程的方式一**
~~~python
import time,random
from multiprocessing import Process
def piao(name):
print('%s piaoing' %name)
time.sleep(random.randrange(1,5))
print('%s piao end' %name)
if __name__ == '__main__':
#实例化得到2个对象
p1=Process(target=piao,args=('egon',)) #必须加逗号
p2=Process(target=piao,args=('alex',))
#调用对象下start的方法，开启2个进程
p1.start()
p2.start()
print('主.....')
~~~
**运行结果**
```
主.....
egon piaoing
alex piaoing
egon piao end
alex piao end
```
### **创建并开启子进程的方式二**
自定义类的时候,必须要实现run方法,因为`Process`中的`start`方法就是调用的`run`方法实现的,当然最好也要用super方法继承父类的初始化数据.
~~~
import time
import random
from multiprocessing import Process
class Piao(Process):
def __init__(self,name):
super().__init__()
self.name=name
def run(self):
print('%s piaoing' %self.name)
time.sleep(random.randrange(1,5))
print('%s piao end' %self.name)
if __name__ == '__main__':
#实例化得到2个对象
p1=Piao('egon')
p2=Piao('alex')
#调用对象下start的方法，开启2个进程
p1.start() #start会自动调用run
p2.start()
print('主....')
~~~
运行结果同上
## **四 Process对象的join方法**
在主进程运行过程中如果想并发地执行其他的任务，我们可以开启子进程，此时主进程的任务与子进程的任务分两种情况
* 情况一：
在主进程的任务与子进程的任务彼此独立的情况下，主进程的任务先执行完毕后，主进程还需要等待子进程执行完毕，然后统一回收资源。
* 情况二：
如果主进程的任务在执行到某一个阶段时，需要等待子进程执行完毕后才能继续执行，就需要有一种机制能够让主进程检测子进程是否运行完毕，在子进程执行完毕后才继续执行，否则一直在原地阻塞，这就是join方法的作用
### 演示代码:
~~~
from multiprocessing import Process
import time,random,os
def task():
print('%s is piaoing' %os.getpid())
time.sleep(random.randrange(1,3))
print('%s is piao end' %os.getpid())
if __name__ == '__main__':
p1=Process(target=task)
p2=Process(target=task)
p1.start()
p2.start()
p1.join()#等待p停止,才执行下一行代码
p2.join()
print('主')
#执行结果
6096 is piaoing
9776 is piaoing
6096 is piao end
9776 is piao end
主
~~~
>p.join()是让主线程等待p的结束，卡住的是主进程而绝非子进程p
可以使用for 循环来简化代码
~~~
p_l=[p1,p2,p3,p4]
for p in p_l:
p.start()
for p in p_l:
p.join()
~~~
## **五 守护进程**
关于守护进程需要强调两点：
其一：守护进程会在主进程代码执行结束后就终止
其二：守护进程内无法再开启子进程,否则抛出异常
>如果我们有两个任务需要并发执行，那么开一个主进程和一个子进程分别去执行就ok了
>如果子进程的任务在主进程任务结束后就没有存在的必要了，那么该子进程应该在开启前就被设置成守护进程。
>主进程代码运行结束，守护进程随即终止
~~~
from multiprocessing import Process
import time,random
def task(name):
print('%s is piaoing' %name)
time.sleep(random.randrange(1,3))
print('%s is piao end' %name)
if __name__ == '__main__':
p=Process(target=task,args=('egon',))
p.daemon=True #一定要在p.start()前设置
p.start()
print('主......') #只要终端打印出这一行内容，那么守护进程p也就跟着结束掉了
#运行结果:子进程还没来得及打印,主进程就结束了,子进程也就结束了
主......
~~~
