# ### 进程 process

import os,time
"""
# ps -aux 查看进程号
# ps -aux | grep 2784 过滤查找2784这个进程

# 强制杀死进程
kill -9 进程号

# 获取当前进程号
res = os.getpid()
print(res)

# 获取当前进程的父进程
res = os.getppid()
print(res)
"""

from multiprocessing import Process
# (1) 进程的使用
"""
def func():
    # 1.子进程id:3561,2.父进程id:3560
    print("1.子进程id:{},2.父进程id:{}".format(os.getpid(),os.getppid()))

if __name__ == "__main__":
    # 创建子进程 ,返回进程对象
    p = Process(target=func)
    # 调用子进程
    p.start()
    
    # 3.主进程id:3560,4.父进程id:3327
    print("3.主进程id:{},4.父进程id:{}".format(os.getpid(),os.getppid()))
"""

# (2) 创建带有参数的进程
"""
def func(n):
    time.sleep(1)
    for i in range(1,n+1): # 0 ~ n-1
        print(i)
        print("1.子进程id:{},2.父进程id:{}".format(os.getpid(),os.getppid()))
        
if __name__ == "__main__":
    n = 6
    # target=指定任务  args = 参数元组
    p = Process(target=func , args=(n,))
    p.start()
    
    for i in range(1,n+1):
        print("*" * i)
"""

# (3) 进程之间的数据彼此隔离
"""
total = 100
def func():
    global total
    total +=1
    print(total)
    
if __name__ == "__main__":
    p = Process(target=func)
    p.start()
    
    time.sleep(1)
    print(total)
"""

# (4) 进程之间的异步性
"""
1.多个进程之间是异步的并发程序,因为cpu调度策略问题,不一定先执行哪一个任务
默认来看,主进程执行速度稍快于子进程,因为子进程创建时,要分配空间资源可能会阻塞
阻塞态,cpu会立刻切换任务,以让程序整体的速度效率最大化

2.默认主进程要等待所有的子进程执行结束之后,在统一关闭程序,释放资源
若不等待,子进程可能不停的在系统的后台占用cpu和内存资源形成僵尸进程.
为了方便进程的管理,主进程默认等待子进程.在统一关闭程序;
"""

def func(n):
    print("1.子进程id:{},2.父进程id:{}".format(os.getpid(),os.getppid()) , n )

if __name__ == "__main__":
    for i in range(1,11):
        p = Process(target=func,args=(i,))
        p.start()

    print("主进程执行结束了 ... " , os.getpid() )
    

# ### 1.同步主进程和子进程 : join

"""必须等待当前的这个子进程执行结束之后,再去执行下面的代码;,用来同步子父进程;"""
from multiprocessing import Process
import time 

# (1) join 的基本使用
"""
def func():
    print("发送第一封邮件 :  我的亲亲领导,你在么?")    

if __name__ == "__main__":
    p = Process(target=func)
    p.start()
    # time.sleep(0.1)
    p.join()
    print("发送第二封邮件 :  我想说,工资一个月给我涨到6万")
"""
 
# (2) 多进程场景中的join
"""
def func(i):
    time.sleep(1)
    print("发送第一封邮件{} :  我的亲亲领导,你在么?".format(i))
    
if __name__ == "__main__":
    lst = []
    for i in range(1,11):
        p = Process(target=func,args=(i,))
        p.start()
        # join 写在里面会导致程序变成同步
        lst.append(p)
        
    # 把所有的进程对象都放在列表中,统一使用.join进行管理;
    for i in lst:
        i.join()
        
        
    print("发送第二封邮件 :  我想说,工资一个月给我涨到6万")
"""

# ### 2使用自定义进程类,创建进程

# (1) 基本语法
import os

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

if __name__ == "__main__":
    p = MyProcess()
    p.start()
        
    
# (2) 带有参数的自定义进程类

class MyProcess(Process):

    def __init__(self,name):
        # 手动调用一下父类的构造方法,完成系统成员的初始化;
        super().__init__()
        self.name = name
    
    def run(self):
        print("1.子进程id:{},2.父进程id:{}".format(os.getpid(),os.getppid()))
        print(self.name)
        
if __name__ == "__main__":
    p = MyProcess("我是参数")
    p.start()    

# ### 守护进程

"""
守护进程守护的是主进程,当主进程所有代码执行完毕之后,立刻强制杀死守护进程;
"""

from multiprocessing import Process
import time

# (1) 基本语法
"""
def func():
    # time.sleep(1)
    print("start... 当前的子进程")
    print("end ...  当前的子进程")

if __name__ == "__main__":
    p = Process(target=func)
    # 在进程启动之前,设置守护进程
    p.daemon = True    
    p.start()    

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

# (2) 多个子进程的守护场景;
"""默认主进程等待所有非守护进程,也就是子进程执行结束之后,在关闭程序,释放资源
守护进程只要在主进程代码执行结束时,就会自动关闭;
"""

"""
def func1():
    print("start ... func1 执行当前子进程 ... ")
    print("end ...   func1 结束当前子进程 ... ")
    
def func2():
    count = 1
    while True:
        print("*" * count)
        time.sleep(1)
        count += 1

if __name__ == "__main__":
    p1 = Process(target=func1)
    p2 = Process(target=func2)
    
    # 把p2这个进程变成守护进程;
    p2.daemon = True
    p1.start()
    p2.start()
    
    print("主进程执行结束 ... ")
"""

# (3) 守护进程用途: 监控报活
def alive():
    while True:
        print("3号服务器向总监控服务器发送报活信息: i am ok~")
        time.sleep(1)
        
def func():
    while True:
        try:
            print("3号服务器负责抗住3万用户量的并发访问...")
            time.sleep(3)
            
            # 主动抛出执行错误的异常,触发except分支
            raise RuntimeError            
            
        except:
            print("3号服务器扛不住了.. 快来修理我..")
            break
            
            
if __name__ == "__main__":
    p1 = Process(target=alive)
    p2 = Process(target=func)

    p1.daemon = True
    p1.start()
    p2.start()
    
    # 必须等待p2这个子进程执行完毕之后,再放行主进程下面的代码
    # 下面主进程代码执行结束,立刻杀死守护进程,失去了报活功能;
    p2.join()
    
    
    print("主进程执行结束  .... ")

#作业:
""" 使用多进程的方式  完成tcp服务端的并发 """