进程相关知识

1.什么是进程：

　　windows:

　　ctrl + alt + del 任务管理器 查看进程

进程：运行的程序就是进程，是资源分配的最小单位

资源分配：分配的是cpu和内存等物理资源

进程号：是进程的唯一标识

　　　　：同一个程序执行两次之后是两个进程

进程和进程之间的关系 ：数据彼此隔离,通过socket通信

（1）进程的基本用法：

 1 from multiprocessing import Process
 2 def func():
 3     print("1.子进程id%s，2.父进程id%s"%(os.getpid(),os.getppid()))
 4 
 5 if __name__  == "__main__":
 6     print("3.子进程id%s，4.父进程id%s"%(os.getpid(),os.getppid()))
 7     # 创建一个子进程，单独执行func这个任务，返回p进程对象
 8     # target = 函数 让当前子进程执行的任务
 9     p = Process(target=func)
10     p.start()

获取当前进程号（子进程）os.getpid()
获取父进程的id号 os.getppid()

（2）带有参数的函数任务

from multiprocessing import Process
def func(n):
    for i in range(1,n+1):
        print("1.子进程id%s，2.父进程id%s"%(os.getpid(),os.getppid()))

if __name__ == "__main__":
    n = 5
    # 创建子进程
    p = Process(target=func,args=(n,))
    # 调用子进程
    p.start()

    for i in range(1,n+1):
        print("*"*i)

"""
process 创建进程对象，参数要依次靠args进行传递
args必须制定一个元素，参数和参数之间要用逗号进行分割
"""

（3）进程之间的数据彼此隔离

from multiprocessing import Process
count = 100
def func():
    global count
    count += 1
    print("我是子进程count",count) # 101

if __name__ == "__main__":
    p = Process(target=func)
    p.start()

    time.sleep(1)
    print("我是主进程count：",count) # 100

（4）多个进程同时并发，子父进程之间的关系

     默认程序在并发任务的时候，因为cpu调度策略
    不一定哪个进程先执行，哪个进程后执行。要参照哪个进程新变成就绪状态，cpu就会优先执行
    cup遇到阻塞，就会立刻切换进程任务

    主进程会在执行结束后，等所有子进程执行完毕，最后在关闭程序，释放资源
    如果不等待子进程，子进程会在后台不停的占用资源，造成僵尸程序。
    不方便对该进程进行管理，不知道该进程的来源，会导致维护困难。

from multiprocessing import Process
def func(i):
    print("1.子进程id>>%s，2.父进程id>>%s" % (os.getpid(),os.getppid()) , i)

if __name__ == "__main__":

    for i in range(10):
        Process(target=func,args=(i,)).start()

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

（5）join() 

　　等待所有子程序执行完毕之后，主进程任务继续执行，保证子父进程的同步性

a.基本用法　　

from multiprocessing import Process
import time
import os

def func():
    print("发送第一封邮件")

if __name__ == "__main__":
    p = Process(target=func)
    p.start()

    # time.sleep(0.1)
    p.join() # 必须等待子进程执行完毕之后，在执行下面的代码

    print("发送第二封邮件")

b.多个子进程通过join加阻塞，可以同步子进程和主进程

from multiprocessing import Process
import time
import os
def func(i):
    print("发送%s个邮件"%(i))

if __name__ == "__main__":
    lst = []
    for i in range(10):
        p = Process(target=func,args=(i,))
        p.start()
        # 从结果上达到目的，但是严重损坏了性能，速度下降
        # p.join()
        lst.append(p)
    # print(lst)

    for i in lst:
        i.join()

    print("主进程负责发送最后一封邮件end")

补充：

　　同步：就是在发出一个功能调用时，在没有得到结果之前，该调用就不会返回。按照这个定义，其实绝大多数函数都是同步调用。

　　异步：异步的概念和同步相对。当一个异步功能调用发出后，调用者不能立刻得到结果。当该异步功能完成后，通过状态、通知或回调来通知调用者。

　　并发：是伪并行，即看起来是同时运行。单个cpu+多道技术就可以实现并发，（并行也属于并发）

　　并行：同时运行，只有具备多个cpu才能实现并行

 2.使用自定义类类的方法创建进程

自定义创建进程的要求：
（1）必须继承Process这个父类
（2）所有的逻辑要写在run方法里面，它会自动调用run

（1）基本语法

from multiprocessing import Process
import time
import os

class MyProcess(Process):
    # 方法名字必须是run
    def run(self):
        print("1.子进程>>%s, 2.父进程>>%s"% (os.getpid(),os.getppid()))

if __name__ == "__main__":
    # 创建进程对象
    p = MyProcess()
    # 调用进程
    p.start()
    print("3.子进程>>%s 4.父进程>>%s"% (os.getpid(),os.getppid()))

(2) 往自定义的进程中传参

from multiprocessing import Process
import time
import os

class MyProcess(Process):
    def __init__(self,args):
        # 必须手动调用一下父类的构造方法，进行系统的初始化
        super().__init__()
        # 将传进来的参数，赋值给一个成员属性args
        self.args = args

    def run(self):
        print("1.子进程>>%s, 2.父进程>>%s" % (os.getpid(),os.getppid()),self.args)

if __name__ == "__main__":
    lst = []
    for i in range(10):
        p = MyProcess(i)
        p.start()
        lst.append(p)

    for i in lst:
        i.join()
    print("主进程结束，主进程%d" % (os.getpid()))

3.守护进程

　　默认情况下，主进程要等待所有子进程执行完毕之后，才会关闭程序，释放资源
　　守护进程进行在主进程代码执行结束之后，就直接关闭
　　守护进程守护的是：主进程

语法：
进程.deamon = True 设置当前这个进程是守护
守护主进程，如果主进程执行代码结束了，守护进程立刻终止
必须要写在start（）调用之前，进行设置

(1) 基本语法

from multiprocessing import Process
import time

def func():

    print("当前子进程start")
    print("当前子进程end")

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

（2） 多个子进程场景

from multiprocessing import Process
import time
def func1():
    count = 1
    while True:
        print("*" * count) # 守护进程，直接死掉
        time.sleep(0.5)
        count += 1

def func2():
    print("func2 stsrt...") # 非守护
    time.sleep(2)
    print("func2 end...")


if __name__ == "__main__":
    p1 = Process(target=func1)
    p2 = Process(target=func2)

    # 将p1设置成守护进程
    p1.daemon = True
    p1.start()
    p2.start()

    # 延迟1秒，让守护进程执行2次
    time.sleep(1)

    print("主进程代码执行结束")

（3） 守护进程的实际用途：监控报活

from multiprocessing import Process
import time

def alive():
    while True:
        print("10号服务器目前运行的状态正常、、、")
        time.sleep(0.5)

def func():
    # 假如func在执行3秒之后，系统挂了
    time.sleep(3)
    print("当前服务器，用来统计财务报表")

if __name__ == "__main__":
    p1 = Process(target=alive)
    p1.deamon = True
    p1.start()

    p2 = Process(target=func)
    p2.start()

    # 如果统计报表的任务挂掉了，立刻终止报活
    p2.join()

    print("目前服务器正常运行。。")