进程part1
很多人学习python，不知道从何学起。
很多人学习python，掌握了基本语法过后，不知道在哪里寻找案例上手。
很多已经做案例的人，却不知道如何去学习更加高深的知识。
那么针对这三类人，我给大家提供一个好的学习平台，免费领取视频教程，电子书籍，以及课程的源代码！
QQ群：101677771
一、进程介绍
进程就是正在运行的程序，它是操作系统中，资源分配的最小单位
资源分配：分配的是cpu和内存等物理资源，进程号是进程的唯一标识
获取当前进程–子进程
异步和同步：
1、获取子父进程
os.getpid()
获取当前进程的父进程
os.getppid()
为解决Windows系统和Linux系统的兼容问题，下面这句话必须加上：
__name__ == “__main__”
def func():
res1=os.getpid()
res2=os.getppid()
print(res1,res2)
#创建子进程，返回进程对象,执行func这个任务
if __name__ == "__main__":
P=Process(target=func)
P.start()
运行结果：
2、进程的基本使用
引用multiprocessing模块来创建以一个进程：
from multiprocessing import Process
import os
def func():
print("子进程为>>{},父进程为>>{}".format(os.getpid(),os.getppid()))
#为解决系统兼容性问题，必须加下面这句话
if __name__ == "__main__":
#创建子进程，返回进程对象，执行func这个任务
p=Process(target=func)
#调用子进程
p.start()
运行结果：
2、创建带有参数的进程
在进程对象的创建处使用args进行传参
from multiprocessing import Process
import os
def func(m,n):
print("子进程为>>{},父进程为>>{}".format(m,n))
#为解决系统兼容性问题，必须加下面这句话
if __name__ == "__main__":
#创建子进程，返回进程对象，执行func这个任务
p=Process(target=func,args=(os.getpid(),os.getppid()))
#调用子进程
p.start()
运行结果：
3、进程之间的数据彼此隔离
from multiprocessing import Process
import time
count=0
def func():
global count
count += 1
print("count:{}".format(count))
if __name__ == "__main__":
p=Process(target=func)
p.start()
time.sleep(1)
print(count)
运行结果：
如图，子进程对count的操作没有影响到主进程
4、多个进程之间的异步并发
多个进程之间是异步并发的程序，因为cpu的调度策略问题，不一定哪个程序先执行，哪个程序后执行
整体而言，主进程比子进程创建的速度要快，cpu遇到阻塞会立即切换任务，等到阻塞态的任务变成了就绪态，cpu再回来执行
主程序会默认等到所有子程序执行结束之后，再统一关闭程序，释放资源
若不等待，有可能在后台存有多个未执行结束的子进程，会变成僵尸进程，不停的占用cpu和内存。
import time,random,os
from multiprocessing import Process
def func(n):
time.sleep(random.randrange(3))
print("{},子进程:{},父进程:{}".format(n,os.getpid(),os.getppid()))
if __name__ == "__main__":
for i in range(10):
p=Process(target=func,args=(i,))
p.start()
print("主程序结束了")
print(os.getpid())
运行结果：
如图，因为多个进程之间是异步并发的，所以会产生以上结果
二、join
等待当前子进程全部执行完毕后，主进程再进行执行
1、基本语法
import os,time
from multiprocessing import Process
def func1():
print("子进程:{}".format(os.getpid()))
def func2():
time.sleep(0.5)
print("父进程:{}".format(os.getppid()))
if __name__ == "__main__":
p1=Process(target=func1)
p2=Process(target=func2)
p1.start()
p2.start()
#引入join，所有子进程执行完成后执行主进程
p1.join()
p2.join()
print("主进程执行完毕")
运行结果：
2、使用自定义类的方法创建进程
自定义进程类的要求：
- 必须继承Process这个父类
- 所有进程执行任务的逻辑必须写在run方法里面
基本写法：
import os,time
from multiprocessing import Process
class MyProcess(Process):
def run(self):
print("子进程:{},父进程:{}".format(os.getpid(),os.getppid()))
if __name__ == "__main__":
p=MyProcess()
p.start()
p.join()
print("主进程执行结束")
带有参数自定义类的方法：
import os,time
from multiprocessing import Process
class MyProcess(Process):
def __init__(self,arg):
self.arg=arg
super().__init__()
def run(self):
print(self.arg)
print("子进程:{} 主进程:{}".format(os.getpid(),os.getppid()))
if __name__=="__main__":
p=MyProcess(arg="我是传参")
p.start()
p.join()
print("主进程执行结束")
运行结果：
三、守护进程
守护进程守护的是主进程，如果主进程中的所有代码执行完毕了，当前这个守护进程会被立刻杀死，立即终止。
语法：
进程.daemon = True 设置当前这个进程为守护进程
必须在start()调用进程之前进行设置
默认：主进程会等待所有子进程执行结束后，再关闭程序，释放资源
from multiprocessing import Process
import time
def func1():
while True:
time.sleep(0.5)
print("我是守护进程！")
def func2():
time.sleep(3)
print("我是子进程！")
if __name__ == "__main__":
p1=Process(target=func1)
p2=Process(target=func2)
p1.daemon=True
p1.start()
p2.start()
time.sleep(2)
print("主进程执行")
运行结果：
案例：
监控报活: 利用守护进程特性，监控日志分析服务器是否存活
from multiprocessing import Process
import time
def alive():
while True:
time.sleep(0.5)
print("P1:服务器存活...")
def func():
count=0
while True:
try:
time.sleep(0.5)
print("P2:服务器日志分析中...")
time.sleep(1)
count += 1
if count == 3:
raise RuntimeError
except:
break
if __name__ == "__main__":
p1=Process(target=alive)
p2=Process(target=func)
p1.daemon=True
p1.start()
p2.start()
p2.join()
print("服务器出现异常！")
运行结果：