进程
1.进程 process
# 进程 process
"""
Linux 查看后台进程 : ps -aux
进程号是进程的唯一标识:
获取进程号:
os.getpid() 获取当前进程ID号
os.getppid() 获取当前进程的父进程ID号
强制杀死进程 : kill -9 进程号
"""
import os,time
from multiprocessing import Process #引用进程类
# 1.进程基本语法
def func():
print("当前进程ID{},父进程ID{}, 111".format(os.getpid(),os.getppid()))
if __name__ == "__main__": #为了兼容Windows和Linux,此条件必须写
p = Process(target = func) #创建子进程对象
p.start() #调用子进程
# 在主进程中,打印进程ID号
print("当前进程ID{},父进程ID{}, 222".format(os.getpid(),os.getppid()))
"""
当前进程ID3051,父进程ID2308, 222 主进程打印的是本文件进程ID和pycharm进程ID
当前进程ID3052,父进程ID3051, 111 子进程打印的是子进程ID和值进程ID
"""
# 2.创建带有参数的进程
def func(n):
for i in range(n):
print(i,"当前进程ID{},父进程ID{}, 111".format(os.getpid(),os.getppid()))
if __name__ == "__main__":
n = 10
#target = 指定执行的任务 args = 参数元组
p = Process(target = func ,args = (n,)) #创建子进程对象
p.start() #调用子进程
print("江山如此多娇")
# 3.进程之间的数据彼此隔离
num = 10
def func():
global num
num +=1
print(num,"子进程")
if __name__ == "__main__":
p = Process(target = func)
p.start()
time.sleep(0.2)
print(num,"主进程")
"""
11 子进程
10 主进程
"""
# 4.进程的异步性
"""
场景在多任务当中
同步: 必须等我这件事干完了,你在干,只有一条主线,就是同步
异步: 没等我这件事情干完,你就在干了,有至少两条主线,就是异步
阻塞: 比如代码有了input,就是阻塞,必须要输入一个字符串,否则代码不往下执行
非阻塞: 没有任何等待,正常代码往下执行.
"""
"""
1.多个进程在执行时,是异步并发程序,因为cpu的调调策略问题,
那个进程能更快的分配好资源就先执行
遇到阻塞就立即切换到就绪状态的任务上,使整体效率最大化
2.主进程默认会等待所有的子进程都执行完毕后,关闭程序,释放资源
孤儿进程 : 主进程执行结束了,子进程还在运行,占用空间资源,称为孤儿进程
僵尸进程 : 子进程都执行结束了,主进程还没有收到子进程的退出状态,
主进程不能释放资源,还持续的在内存中保留,称为僵尸进程
"""
def func(n):
print(n,"子进程ID:{},父进程ID:{}".format(os.getpid(),os.getppid()))
if __name__ =="__main__":
for i in range(6):
p = Process(target = func,args = (i,))
p.start()
print("主进程结束~!")
2.同步进程和自定义进程类
# 一 : 同步主进程和子进程
"""
语法 : 进程对象.join()
意义 : 必须等待当前子进程执行结束后,再去执行下面的代码
作用 : 用来同步子父进程
"""
from multiprocessing import Process
# 1.join 基本使用
def func():
print("第一个~")
if __name__ == "__main__":
p = Process(target = func)
p.start()
p.join()
print("第二个~")
"""
第一个~
第二个~
"""
# 2.多进程场景
def func(n):
print("这是第{}个~".format(n))
if __name__ =="__main__":
lst = []
for i in range(5):
p = Process(target = func , args = (i,))
p.start()
# p.join() 此处用join会导致程序由异步并发,变成同步进程,降低了执行效率
lst.append(p) #可以先异步创建多个进程对象,放到列表中
for i in lst: #再调用join进行同步管理
i.join()
print("最后一个了~")
# 二 : 使用自定义进程类,创建进程
# 1.基本写法
"""
自定义进程类:
必须继承父类Process
必须定义run方法
"""
from multiprocessing import Process
class MyProcess(Process):
def run(self):
print("生活就是这样~")
if __name__ == "__main__":
p = MyProcess()
p.start()
p.join()
print("不然你要怎样~")
"""
不然你要怎样~
生活就是这样~
"""
# 2.带有参数的自定义进程类
class My(Process):
def __init__(self,name):
self.name = name
super().__init__() #手动调用父类的构造方法,完成成员初始化
def run(self):
print(self.name)
if __name__ == "__main__":
p = My("我们是祖国的花朵~")
p.start()
p.join()
print("着装好看~")
3.守护进程
# 守护进程
"""
守护进程守护的是主进程
当主进程的所有代码执行结束后,会立刻终止守护进程
守护进程内无法再开启子进程,否则抛出异常
"""
from multiprocessing import Process
import time
# 1.基本语法
def func():
print("子进程启动")
if __name__ == "__main__":
p = Process(target = func)
p.daemon = True #设置守护进程,在start调用之前
p.start()
print("主进程代码执行结束~")
"""
主进程代码执行结束~
"""
# 2.多个子进程情况
def func1():
print("我是老大~")
def func2():
print("我是老二~")
if __name__ == "__main__":
p1 = Process(target = func1)
p2 = Process(target = func2)
p2.daemon = True #把p2设置成守护程序
p1.start()
p2.start()
print("主进程代码执行结束~")
"""
主进程代码执行结束~
我是老大~
"""
# 3.守护进程用途 : 监控报活
def alive():
while True:
print("1号服务器向总监控服务器报活~")
time.sleep(0.5)
def func():
while True:
try:
print("1号服务器负责抗住1万用户量的并发访问")
time.sleep(3) #三秒后崩溃
raise RuntimeError #主动抛出异常
except:
print("1号服务器挂了...需要维护")
break
if __name__ == "__main__":
p1 = Process(target = alive) #负责报活
p2 = Process(target = func) #抗住用户并发
p1.daemon = True
p1.start()
p2.start()
p2.join() #必须等待2号执行完
print("主进程代码执行结束~")
