进程，join的使用，守护进程---day30

1.进程

# ### 进程
import os,time

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

#当前进程id(父进程)
res = os.getppid
print(res) #1772

#(1) 进程的基本语法
from multiprocessing import Process #先导入这个模块
'''
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()
'''
3.子进程id>>>>1640 , 4.父进程id>>>>6952
1.子进程id>>>>6636 , 2.父进程id>>>>1640
'''

#(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)
#当程序运行到创建子进程的时候，创建空间会阻塞，然后就会先运行下面的for循环
#等到创建子进程变成就绪的时候再回去执行创建子进程的程序
'''
运行结果:
1.子进程id>>>>4556 , 2.父进程id>>>>6952
*
**
***
****
*****
3.子进程id>>>>5276 , 4.父进程id>>>>4556
3.子进程id>>>>5276 , 4.父进程id>>>>4556
3.子进程id>>>>5276 , 4.父进程id>>>>4556
3.子进程id>>>>5276 , 4.父进程id>>>>4556
3.子进程id>>>>5276 , 4.父进程id>>>>4556
'''

#(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)
'''
运行结果:
我是子进程count=101
100
说明子进程和主进程之间的数据是隔离的
'''

#(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()

        print('主程序执行结束...')
'''
运行结果： 执行顺序每次都不一样
3.子进程id>>>>4512 , 4.父进程id>>>>6796 3
3.子进程id>>>>5300 , 4.父进程id>>>>6796 2
3.子进程id>>>>1712 , 4.父进程id>>>>6796 4
主程序执行结束...
3.子进程id>>>>6644 , 4.父进程id>>>>6796 7
3.子进程id>>>>4636 , 4.父进程id>>>>6796 6
3.子进程id>>>>7120 , 4.父进程id>>>>6796 5
3.子进程id>>>>5732 , 4.父进程id>>>>6796 1
3.子进程id>>>>1952 , 4.父进程id>>>>6796 8
3.子进程id>>>>6728 , 4.父进程id>>>>6796 10
3.子进程id>>>>4632 , 4.父进程id>>>>6796 9
'''

2.join

# ### 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()  #在这边加join时，程序会变成同步阻塞减慢速度

    for i in lst:
        print(i)
        i.join()
    print('主进程发最后一封邮件,里面的内容是我发完了')
'''
运行结果:
发送第1封邮件
发送第2封邮件
发送第0封邮件
发送第4封邮件
发送第5封邮件
发送第3封邮件
发送第6封邮件
<Process(Process-1, stopped)>
<Process(Process-2, stopped)>
<Process(Process-3, stopped)>
<Process(Process-4, started)>
<Process(Process-5, stopped)>
<Process(Process-6, stopped)>
<Process(Process-7, started)>
<Process(Process-8, started)>
发送第8封邮件
发送第7封邮件
<Process(Process-9, stopped)>
<Process(Process-10, started)>
发送第9封邮件
主进程发最后一封邮件,里面的内容是我发完了
'''

# ### 使用自定义类的方式创建进程(拓展)
'''
自定义类创建进程要求:
(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()))
'''
运行结果
3.子进程id>>>>4976 , 4.父进程id>>>>6952
1.子进程id>>>>484 , 2.父进程id>>>>4976
'''

#(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()))
运行结果：
3.子进程id>>>>1412 , 4.父进程id>>>>6952
1.子进程id>>>>2140 , 2.父进程id>>>>1412 我是参数

3.守护进程

# ### 守护进程
'''
守护进程守护的是主进程，如果主进程执行结束了，意味着守护进程的寿命立刻终止，立刻杀死
语法：
进程.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('主程序代码结束')
'''
运行结果
*
start func2当前子进程
**
主程序代码结束...
end func2当前子进程
p1和p2都会创建子进程空间，然后运行p1和p2子进程中的程序
然后因为开辟空间的时候会有阻塞，因为不会等到p1和p2全部执行结束后才去执行主程序
此时执行主程序，主程序和p1绑定为守护程序，所以主程序执行完毕就表示p1要全部结束
此时p2在前面睡了2秒，正好p1和主程序都结束了，然后执行p2
'''

#(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('当前服务器状态:统计账务报表功能异常...')
运行结果：
给监控服务器发消息, 当前5号服务器功能正常 i am ok ~
给监控服务器发消息, 当前5号服务器功能正常 i am ok ~
给监控服务器发消息, 当前5号服务器功能正常 i am ok ~
给监控服务器发消息, 当前5号服务器功能正常 i am ok ~
给监控服务器发消息, 当前5号服务器功能正常 i am ok ~
当前5号服务器功能,统计财务报表~
给监控服务器发消息, 当前5号服务器功能正常 i am ok ~
当前服务器状态:统计财务报表功能异常...
解析:首先p1p2子进程开辟空间,然后执行对应的程序,因为p1对象用了join，必须要等p1子进程结束
之后才能执行下面的主程序代码，当主程序代码执行结束后，因p2是守护进程，所以此时的p2的所有
进程都要全部杀掉。