python_learn 进程、join使用及守护进程

# ### 进程
import os,time

"""
# 当前进程id(子进程)
res = os.getpid()
print(res)

# 当前进程的父进程id
res2 = os.getppid()
print(res2)
"""

from multiprocessing import Process

# (1) 进程使用的基本语法
"""
process 创建子进程,返回进程的对象p,
target指定要执行的任务
args指定传递的参数,args的类型是元组,多个参数之间用逗号隔开
"""
"""
def func():
    print("1.子进程id>>>>{} , 2.父进程id>>>>{}".format(os.getpid(),os.getppid()))

# windows里面下面这句话必须要加;
if __name__ == "__main__":
    print("3.子进程id>>>>{} , 4.父进程id>>>>{}".format(os.getpid(),os.getppid()))

    # 创建子进程,返回一个进程对象,执行func任务
    p = Process(target = func) # target指定任务
    # 调用子进程
    p.start()
"""
# (2) 创建带有参数的进程 
"""
def func(n):
    for i in range(1,n+1):
         print("3.子进程id>>>>{} , 4.父进程id>>>>{}".format(os.getpid(),os.getppid()))

if __name__ == "__main__":
    print("1.子进程id>>>>{} , 2.父进程id>>>>{}".format(os.getpid(),os.getppid()))

    n = 5
    # 创建子进程
    p = Process(target=func,args=(n,))
    # 调用子进程
    p.start()
    
    for i in range(1,n+1):
        print("*" * i)
"""

# (3) 进程之间的数据隔离
"""
count = 100
def func():
    global count
    count += 1
    print("我是子进程count={}".format(count))

if __name__ == "__main__":
    p = Process(target=func)
    p.start()
    time.sleep(1)
    print(count)
"""

# (4) 多个进程可以异步并发,子父进程之间的关系;
"""
# 程序在异步并发任务时,因为cpu调度策略问题,不一定先执行谁或者后执行谁,
整体而言,主进程速度快于子进程,cpu遇到阻塞立刻切换其他任务,等到进程的就绪态在切换回来

# 主程序会默认等待所有的子进程执行结束之后,在关闭程序,释放资源
若不等待,子进程并不方便管理,容易造成僵尸进程,在后台不停的占用系统的资源(cpu和内存),不清楚进程的来源.

"""


def func(args):
    print("3.子进程id>>>>{} , 4.父进程id>>>>{}".format(os.getpid(),os.getppid()) , args)

if __name__ == "__main__":
    for i in range(1,11):
        Process(target=func,args = (i,)).start()
    """
    Process(target=func,args = (1,))
    Process(target=func,args = (2,))
    Process(target=func,args = (3,))
    Process(target=func,args = (4,))
    Process(target=func,args = (5,))
    Process(target=func,args = (6,))
    Process(target=func,args = (7,))
    Process(target=func,args = (8,))
    Process(target=func,args = (9,))
    Process(target=func,args = (10,)
    """

    print("主进程执行结束 ....  ")
    

# ### 1.join 等待所有子进程全部执行完毕之后,主进程任务在继续执行,(用来同步子父进程速度的)

from multiprocessing import Process
import os

# (1) join 的基于语法
"""
def func():
    print("发送第一封邮件")

if __name__ == "__main__":
    p = Process(target=func)
    p.start()
    
    # 必须等待子进程执行结束之后,在继续执行主程序中的代码,用来同步代码一致性的;
    p.join() 
    print("发送第二封邮件")
"""
    
# (2) 多个子进程配合join使用
"""
def func(index):
    print("发送第%s封邮件" % (index))
    
if __name__ == "__main__":
    lst = []
    for i in range(10):
        p = Process(target=func,args=(i,))
        p.start()
        lst.append(p)
        # p.join()# 程序会变成同步阻塞,减慢的速度
        
    for i in lst:
        print(i)
        i.join()
    
    print("主进程发最后一封邮件,里面的内容是我发完了")
"""
    
# ### 使用自定义类的方式创建进程(拓展)
"""
自定义类创建进程要求:
(1) 必须继承Process这个父类
(2) 所有进程执行任务的逻辑要写run方法里面
"""

# (1) 基本语法
# class MyProcess(Process):
    # def run(self):
        # print("1.子进程id>>>>{} , 2.父进程id>>>>{}".format(os.getpid(),os.getppid()))

# if __name__ == "__main__":
    # p = MyProcess()
    # p.start()
    # print("3.子进程id>>>>{} , 4.父进程id>>>>{}".format(os.getpid(),os.getppid()))

# (2) 有参数的进程函数
""""""
class MyProcess(Process):

    def __init__(self,arg):
        # 手动调用一下父类的构造方法(实现进程的创建)
        super().__init__()
        self.arg = arg


    def run(self):
        print("1.子进程id>>>>{} , 2.父进程id>>>>{}".format(os.getpid(),os.getppid()),self.arg)

if __name__ == "__main__":
    p = MyProcess("我是参数")
    p.start()
    print("3.子进程id>>>>{} , 4.父进程id>>>>{}".format(os.getpid(),os.getppid()))

 

# ### 守护进程
"""
守护进程守护的是主进程,如果主进程执行结束了,意味着守护进程的寿命立刻终止.立刻杀死
语法:
进程.daemon = True 设置当前进程为守护进程
必须写在start()调用进程之前进行设置

默认情况下,主进程会等待所有子进程执行完毕之后,关闭程序,释放资源
守护进程在主进程代码执行结束之后,直接杀掉.

"""

from multiprocessing import Process
# (1) 基本用法
"""
def func():
    print("start 当前子进程")
    print("end   当前子进程")

if __name__ == "__main__":
    p = Process(target=func)
    p.daemon = True
    p.start()
    print("主进程执行结束 ... ")
"""

# (2) 多个子进程的场景
"""
import time
def func1():
    count = 1
    while True:
        print("*" * count)
        time.sleep(0.5)
        count += 1
    
def func2():
    print("start func2当前子进程")
    time.sleep(2)
    print("end   func2当前子进程")
    

if __name__ == "__main__":
    p1 = Process(target=func1)
    p2 = Process(target=func2)
    
    # 设置当前进程为守护进程
    p1.daemon = True
    
    p1.start()
    p2.start()
    
    time.sleep(1)
    
    # 非守护进程,主进程还是会默认等待的.
    print("主程序代码结束....")
"""

# (3) 守护进程的实际用途: 监控报活
import time
# 监控报活
def alive():
    while True:
        print("给监控服务器发消息, 当前5号服务器功能正常 i am ok ~")
        time.sleep(1)

# 当前服务器正常完成的功能
def func():
    # while True:
    time.sleep(5)
    print("当前5号服务器功能,统计财务报表~")


if __name__ == "__main__":
    p1 = Process(target=func)
    p2 = Process(target=alive)
    p2.daemon = True
    
    p1.start()
    p2.start()
    
    # 等待p1子进程执行结束之后,下面的主程序的代码才会放行;
    p1.join()
    
    print("当前服务器状态:统计财务报表功能异常.....")