day32:进程&进程join&守护进程deamon

目录

1.进程的基本概念

2.进程初体验

3.join:先子后主

4.守护进程:deamon

5.使用自定义类的方式创建进程

6.两张和进程相关的图

进程的基本概念

什么是进程?

进程就是正在运行的程序,它是操作系统中,资源分配的最小单位

什么是资源分配?

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

Linux中几个关于进程的指令

ps -aux    查看进程号

ps -aux | grep 2860   查看对应进程号的进程

kill -9 2860   杀死进程

pid和ppid

获取当前进程id: os.getpid()

获取当前进程的父进程id: os.getppid()

并行和并发

并发:一个cpu同一时间不停执行多个程序

并行:多个cpu同一时间不停执行多个程序

CPU的进程调度算法

1.先来先服务fcfs(first come first server):先来的先执行

2.短作业优先算法:分配的cpu多,先把短的算完

3.时间片轮转算法:每一个任务就执行一个时间片的时间.然后就执行其他的

4.多级反馈队列算法

越是时间长的,cpu分配的资源越少,优先级靠后

越是时间短的,cpu分配的资源越多

进程初体验

1.进程的基本使用

在使用进程之前,需要调用Process: from multiprocessing import Process

# (1) 进程的基本使用
def func():
    print("1.子进程id>>{},2父进程id>>{}".format(os.getpid(),os.getppid()))

# 为了解决windows 和 linux 系统的兼容问题,下面这句话必须加上,否则报错
if __name__ == "__main__":
    # 创建子进程,返回进程对象,执行func这个任务
    p = Process(target=func)
    # 调用子进程
    p.start()

2.创建带有参数的进程

def func(n):
    for i in range(1,n+1):
        print("1.子进程id>>{},2父进程id>>{}".format(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)

执行结果如下图所示

产生如上结果的原因:因为子进程分配资源需要时间，而主进程早已经分配好资源了，不需要这个时间。所以主进程的内容先打印，子进程的内容后打印

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

count = 10
def func():
    global count
    count += 1
    print("我是子进程count={}".format(count))

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

执行结果如下图所示

产生如上结果的原因：如下图所示，黄色部分都是子进程中的内容，子进程中有+1操作，所以子进程中的count肯定为11

但是主进程并没有任何操作，只是单纯的打印了一下count，所以主进程中的count为10

4.多个进程之间是异步并发

关于主进程和子进程，你需要注意的点:

1.多个进程之间是异步并发的程序,因为cpu的调度策略问题,不一定哪个任务先执行,哪个任务后执行.

整体而言,主进程比子进程创建的速度要快,cpu遇到阻塞会立刻切换任务,等到阻塞态的任务变成了就绪态,cpu再回来执行

2.主程序会默认等到所有的子程序执行结束之后,在统一关闭程序,释放资源.

若不等待,有可能在后台存有多个未执行结束的子进程,会变成僵尸进程,不停的占用cpu,内存

增加系统的压力,所有方便于对进程的管理,主进程默认等待子进程.

def func(n):
    time.sleep(random.randrange(3))
    print("数字{}<=>1.子进程id>>{},2父进程id>>{}".format(n,os.getpid(),os.getppid()))

if __name__ == "__main__":
    for i in range(1,11):
        Process(target=func,args=(i,)).start()
        
    print("主进程执行结束了....")
    print(os.getpid())

执行结果如下图所示

join:先子后主

1.join基本语法

def func():
    print("发送第一封邮箱,要求涨工资")


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

    # 必须等待子进程全部执行结束之后,在执行主进程中的代码,用join来同步子父进程.
    p.join()
    # time.sleep(1)
    print("发送第二封邮箱,涨到一个月6万")

执行结果如下图所示

2.join:多个子进程

def func(i):
    time.sleep(1)
    print("发送第%s封邮箱,要求升职加薪" % (i))


if __name__ == "__main__":
    lst = []
    for i in range(10):
        p = Process(target=func, args=(i,))
        p.start()
        lst.append(p) # 把创建的十个子进程对象方放到列表中，现在他们处于就绪态

    for i in lst:
        i.join() # 十个子进程对象同时join

    print("主进程发最后一封邮件:此致敬礼~")

执行结果如下图所示

请注意!!!千万不要写成如下写法:

守护进程deamon

1.守护进程的基本概念 

概念:

守护进程守护的是主进程,如果主进程中的所有代码执行完毕了,

当前这个守护进程会被立刻杀死,立刻终止.

语法:

进程.daemon = True---->设置当前这个进程为守护进程

必须写在start()调用进程之前进行设置

2.守护进程的基本使用方法

def func():
    print("start当前子进程")
    time.sleep(1)
    print("end当前子进程")


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

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

执行结果如下图所示

3.守护进程：多个子进程

def func1():
    count = 1
    while True:
        print("*" * count)
        time.sleep(0.5)
        count += 1


def func2():
    print("start func2 当前子进程任务")
    time.sleep(3)
    print("end   func2 当前子进程任务")


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

    # 设置p1这个进程对象为守护进程
    p1.daemon = True

    p1.start()
    p2.start()

    time.sleep(1)

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

执行结果如下图所示

4.守护进程实际用途:监控报活

# 守护进行
def alive():
    while True:
        print("给监控的总服务器发消息,报告自己的存活状态, i am alive~")
        time.sleep(1)


# 执行任务
def func():
    while True:
        try:
            time.sleep(1)
            raise RuntimeError
            print("当前5号服务器功能:对日志进行数据分析.... ")
        except:
            break
        # pass


if __name__ == "__main__":
    # 创建2个子进程
    p1 = Process(target=alive)
    p2 = Process(target=func)
    # 设置p1为守护进程
    p1.daemon = True

    p1.start()
    p2.start()

    # 必须等到p2任务执行结束之后,在向下执行.
    p2.join()

    print("当前服务器状态异常 ... ")

在一切都很正常的时候,它的运行结果是这样的

当出现问题时,它的运行结果是这样的

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

自定义进程类的要求

自定义进程类的要求:

(1) 必须继承Process这个父类

(2) 所有进程执行任务的逻辑必须写在run方法里面

基本语法

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

带有参数自定义类的方法

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()))
        print(self.arg)
    
if __name__ == "__main__":
    p = MyProcess("我是传进来的参数")
    p.start()
    print("3.子进程id>>{},4父进程id>>{}".format(os.getpid(),os.getppid()))

运行结果如下图所示

请注意:在定义类中重写__init__方法中，必须要用super调用父类的__init__方法!!!

如果没有调用的话，会出现以下这种情况:

我们可以查看父类的__init__方法

所以，我们使用super直接调用父类的__init__方法

两张和进程相关的图