什么是进程
- 进程：一个程序的执行过程或者一个任务。
- 并发： 是伪并行，看起来是同时运行，其实通过单个cpu+多道技术就可以实现并发。
- 并行： 同时运行，只有具备多个cpu才能实现并行。
新进程的创建都是由一个已经存在的进程执行了一个用于创建进程的系统调用而创建的：
在UNIX中系统调用是:fork。 fork 会创建和父进程一模一样的副本，在初始状态，二者有相同的存储映像和数据，同样的环境字符串和同样的打开文件（在shell解释器进程中，执行一个命令就会创建一个子进程）
在windows中，该系统调用的是 CreateProcess, CreateProcess既处理进程的创建，也负责把正确的程序装入新的进程。
关于创建进程，UNIX和Windows:
相同的是：进程创建后，父进程和子进程有各自不同的内存地址空间（多道技术要求物理层面实现进程之间的内存隔离），任何一个进程修改自身的空间数据都不会影响到另一个进程。
不同的是：在UNIX 中，子进程的初始地址空间是父进程的一个副本，子进程和父进程是可以有只读的共享存储区。但是在Windows中，从一开始，父进程和子进程的地址空间就是不同的。
开启进程的两种方式
方式一
开启进程（使用提供的模块）：
# coding=utf-8
from multiprocessing import Process # 进程模块
import time
def task(name):
print('%s is running' %name)
time.sleep(2)
print('%s is done' %name)
if __name__ == '__main__': # 在Windows系统上，进程开启前需要先定义进程执行函数，进程的执行代码必须放在开启进程代码前
p=Process(target=task,args=('cat',)) # target 指定进程函数，args指定参数，参数必须为元组
p.start()
print('主')
输出结果：
主
cat is running
cat is done
方式二
自定义进程：
# coding=utf-8
from multiprocessing import Process
import time
class MyProcess(Process): # 自定义类，继承系统的Process
def __init__(self,name):
super(MyProcess,self).__init__()
self.name=name
def run(self):
print('%s is running' %self.name)
time.sleep(2)
print('%s is done' %self.name)
if __name__ == '__main__':
p=MyProcess('进程1')
p.start() # 调用 run() 函数
print('主')
输出结果：
主
进程1 is running
进程1 is done
进程的隔离
创建进程的过程中，子进程在初始状态会拷贝父进程中的数据，但是在自己运行过程中，修改子进程自己的数据不会影响父进程的数据，进程之间的数据是相互隔离的：
# coding=utf-8
from multiprocessing import Process # 进程模块
import time
n = 100
def task(name):
global n
n = 0
time.sleep(2)
print('子进程',n)
if __name__ == '__main__':
p=Process(target=task,args=('cat',))
p.start()
p.join() # 等待子进程运行完毕后再运行后面主进程的代码
print('主进程',n)
输出结果：
子进程 0
主进程 100
进程相关的方法
join 方法
# coding=utf-8
import os
from multiprocessing import Process # 进程模块
import time
def task(n):
print('%s is running' %os.getpid())
time.sleep(n)
print('%s is done' %os.getpid())
if __name__ == '__main__':
p1 = Process(target=task,args=(1,))
p2 = Process(target=task,args=(2,))
p3 = Process(target=task,args=(3,))
start_time=time.time() # 开启进程计时
p1.start()
p2.start()
p3.start()
p1.join() # 等待1s p1结束
p2.join() # 等待1s p2结束
p3.join() # 等待1s p3结束
stop_time=time.time() # 计时结束
print('主进程',(stop_time-start_time))
运行结果：
16188 is running
228 is running
13480 is running
16188 is done
228 is done
13480 is done
主进程 3.086230516433716
可以改写以上代码：
# coding=utf-8
import os
from multiprocessing import Process # 进程模块
import time
def task(n):
print('%s is running' %os.getpid())
time.sleep(n)
print('%s is done' %os.getpid())
if __name__ == '__main__':
p1 = Process(target=task,args=(1,))
p2 = Process(target=task,args=(2,))
p3 = Process(target=task,args=(3,))
start_time=time.time() # 开启进程计时
p_list=[p1,p2,p3]
for p in p_list:
p.start()
for p in p_list:
p.join()
stop_time=time.time() # 计时结束
print('主进程',(stop_time-start_time))
如果要改为串行执行，可以用如下方式：
# coding=utf-8
import os
from multiprocessing import Process # 进程模块
import time
def task(n):
print('%s is running' %os.getpid())
time.sleep(n)
print('%s is done' %os.getpid())
if __name__ == '__main__': # 如果串行执行，可以不调用此处的方法
p1 = Process(target=task,args=(1,))
p2 = Process(target=task,args=(2,))
p3 = Process(target=task,args=(3,))
start_time=time.time() # 开启进程计时
task(1)
task(2)
task(3)
stop_time=time.time() # 计时结束
print('主进程',(stop_time-start_time))
输出结果：
12116 is running
12116 is done
12116 is running
12116 is done
12116 is running
12116 is done
主进程 6.001911163330078
其它常见方法
- p.start(): 启动进程，并调用子进程中的p.run()
- p.run(): 进程启动时运行的方法，正是它去调用target指定的函数，自定义的类中一定要实现该方法。
- p.terminate(): 强制终止进程p,不会进行任何清理操作，如果p 创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况，如果P还保存了一个锁那么也不会被释放，进而导致死锁。
- p.is_alive(): 如果p仍然运行，返回True
- p.join([timeout]): 主线程等待p终止（p处于运行的状态，主线程处于等待状态）。timeout是可选的超时时间。p.join只能join住start开启的进程，不能join住run开启的进程
进程属性
- p.daemon: 默认值为False,如果设置为True,代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并设定为True之后，P不能创建自己的新进程，必须在p.start()之前设置
- p.name: 进程的名称
- p.pid: 进程的pid
- p.exitcode: 进程在运行时为None,如果为-N，表示被信号N结束
- p.authkey: 进程的身份验证键，默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程通信提供安全性，这类连接只有在㕛相同的身份验证键时才能成功
僵尸进程和孤儿进程
僵尸进程
在UNIX中，一个进程使用fork创建子进程，如果子进程退出，而父进程并没有调用wait或waitpid获取子进程的状态信息，那么子进程的进程描述符仍然保存在系统中。这种进程称之为僵尸进程。详解如下
我们知道在unix/linux中，正常情况下子进程是通过父进程创建的，子进程在创建新的进程。子进程的结束和父进程的运行是一个异步过程,即父进程永远无法预测子进程到底什么时候结束，如果子进程一结束就立刻回收其全部资源，那么在父进程内将无法获取子进程的状态信息。
因此，UNIX提供了一种机制可以保证父进程可以在任意时刻获取子进程结束时的状态信息：
- 在每个进程退出的时候，内核释放该进程所有的资源，包括打开的文件，占用的内存等。但是仍然为其保留一定的信息（包括进程号the process ID，退出状态the termination status of the process，运行时间the amount of CPU time taken by the process等）
- 直到父进程通过wait / waitpid来取时才释放. 但这样就导致了问题，如果进程不调用wait / waitpid的话，那么保留的那段信息就不会释放，其进程号就会一直被占用，但是系统所能使用的进程号是有限的，如果大量的产生僵死进程，将因为没有可用的进程号而导致系统不能产生新的进程. 此即为僵尸进程的危害，应当避免。
任何一个子进程(init除外)在exit()之后，并非马上就消失掉，而是留下一个称为僵尸进程(Zombie)的数据结构，等待父进程处理。这是每个子进程在结束时都要经过的阶段。如果子进程在exit()之后，父进程没有来得及处理，这时用ps命令就能看到子进程的状态是“Z”。如果父进程能及时 处理，可能用ps命令就来不及看到子进程的僵尸状态，但这并不等于子进程不经过僵尸状态。 如果父进程在子进程结束之前退出，则子进程将由init接管。init将会以父进程的身份对僵尸状态的子进程进行处理。
僵尸进程的危害场景
例如有个进程，它定期的产生一个子进程，这个子进程需要做的事情很少，做完它该做的事情之后就退出了，因此这个子进程的生命周期很短，但是，父进程只管生成新的子进程，至于子进程 退出之后的事情，则一概不闻不问，这样，系统运行上一段时间之后，系统中就会存在很多的僵尸进程，倘若用ps命令查看的话，就会看到很多状态为Z的进程。 严格地来说，僵尸进程并不是问题的根源，罪魁祸首是产生出大量僵死进程的那个父进程。因此，当我们寻求如何消灭系统中大量的僵死进程时，答案就是把产生大 量僵死进程的那个元凶枪毙掉（也就是通过kill发送SIGTERM或者SIGKILL信号啦）。枪毙了元凶进程之后，它产生的僵尸进程就变成了孤儿进 程，这些孤儿进程会被init进程接管，init进程会wait()这些孤儿进程，释放它们占用的系统进程表中的资源，这样，这些已经僵死的孤儿进程 就能瞑目而去了
在unix系统中，执行top命令中 zombie的数量就是当前僵尸进程的数量
回收僵尸进程的解决办法
等待父进程正常结束后会调用wait／waitpid去回收僵尸进程
但如果父进程是一个死循环，永远不会结束，那么该僵尸进程就会一直存在，僵尸进程过多，就是有害的
- 解决方法一：杀死父进程
- 解决方法二：对开启的子进程应该记得使用join，join会回收僵尸进程
- 解决办法三：python中有一个signal模块，可以使用signal(SIGCHLD, SIG_IGN)处理僵尸进程
孤儿进程
一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养，并由init进程对它们完成状态收集工作。
孤儿进程是没有父进程的进程，孤儿进程这个重任就落到了init进程身上，init进程就好像是一个民政局，专门负责处理孤儿进程的善后工作。每当出现一个孤儿进程的时候，内核就把孤 儿进程的父进程设置为init，而init进程会循环地wait()它的已经退出的子进程。这样，当一个孤儿进程凄凉地结束了其生命周期的时候，init进程就会代表党和政府出面处理它的一切善后工作。因此孤儿进程并不会有什么危害。
守护进程
守护进程是由主进程创建的子进程：
- 守护进程会在主进程代码结束后就终止。
- 守护进程内无法再开启子进程，否则抛出异常：AssertionError: daemonic processes are not allowed to have children
- 进程之间是相互独立的，主进程代码运行结束，守护进程随即终止。
示例：
# coding=utf-8
import os
from multiprocessing import Process # 进程模块
import time
def task(n):
print('%s is running' %os.getpid())
time.sleep(2)
print('%s is done' %os.getpid())
if __name__ == '__main__':
p = Process(target=task,args=('ggg',))
p.daemon = True # 开启守护进程，必须在start之前设置
p.start()
print("主进程")
输出结果：
主进程
说明： 由于开启了守护进程，当主进程运行结束时，子进程（守护进程）也会终止运行，不管守护进程是否运行完毕。
守护进程的使用场景： 当子进程执行的任务，在父进程代码运行完毕后就没有运行的必要了，那么该子进程就应该设置为守护进程。
守护进程与普通子进程测试：
# coding=utf-8
import os
from multiprocessing import Process # 进程模块
import time
def foo():
print('这是守护进程')
time.sleep(1)
print('守护进程结束')
def bar():
print('这是普通子进程')
time.sleep(2)
print('bar 运行结束')
if __name__ == '__main__':
p1=Process(target=foo)
p2=Process(target=bar)
p1.daemon=True
p1.start()
p2.start()
print("主进程到此结束！")
运行结果：
主进程到此结束！
这是普通子进程
bar 运行结束
