4.进程-1

进程

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("主进程代码执行结束~")