进程进阶

孤儿进程(亚索进程)

我们上次讲了僵尸进程,今天就来讲讲孤儿进程。

所谓孤儿,就是亚索,没爹的东西。

就是一个子进程的父进程挂掉的时候,这个子进程就会成为一个孤鹅,他将会被一个叫做init的进程收养,然后被人道毁灭。说到底,孤鹅进程是没啥关系的,不像僵尸进程,死又死不掉,又占着茅坑不拉屎,最后导致进程号都不够用了。

一共有三种情况:

情况1 无害父进等着子进程都死,回收僵尸进程。

情况2 无害父进程死了,子进程活着,都要被init进程接管并且回收。

情况3父进程一直不死,造成了大量僵尸进程。占用了大量的pid号

解决方案是什么,最直接的办法就是直接把他们的爸爸杀了,只要他们的父进程死了,无论怎么样,这些子进程最后都会挂掉!

Process的join用法

from multiprocessing import Process
import time
def foo():
    print('进程  start ')
    time.sleep(2.3)
    print('进程  end ')



if __name__ == '__main__':
    p = Process(target=foo)
    p.start() #
    # 核心需求就是
    # time.sleep(5)
    p.join() # 阻塞住主进程再等待子进程结束,然后再往下执行,(了解的是:内部会待用wait())
    print('主')

join方法的用处就是阻塞住主进程等子进程结束了再往下走。

优化版:

import time
def foo(x):
    print(f'进程{x}  start ')
    time.sleep(x)
    print(f'进程{x}  end ')



if __name__ == '__main__':
    start = time.time()
    p_list = []
    for i in range(1,4):
        p = Process(target=foo,args=(i,))
        p.start()
        p_list.append(p)
    print(p_list)
    for p in p_list:
        p.join()
    end = time.time()
    print(end-start) #3s多 or 6s多  ?  正解:3s多
    print('主')	

结果是三秒多。自己体会,才是最有味的,主要是我不想解释了

因为在你join之前,每一个子进程都已经start了,所以只用等最后一个结束就好了。

Process的其他用法

import time,os

def task():

    print('子进程 start')
    print('在子进程中查看自己的pid',current_process().pid) # 在子进程中查看自己的pid
    print('在子进程中查看父进程的pid',os.getppid()) #
    time.sleep(200)
    print('子进程 end')

if __name__ == '__main__':

    p = Process(target=task)
    p.start()
    print('在主进程查看子进程的pid',p.pid) # 一定要写在 start()之后
    print('主进程的pid',os.getpid())
    print('主进程的父进程pid',os.getppid())
    print('主')

过目就好

from  multiprocessing import Process,current_process
import time
def foo():
    print('进程 start')
    # print('---------------------    ',current_process().name)
    time.sleep(2)
    print('进程 end')


if __name__ == '__main__':
    p = Process(target=foo)
    # p2 = Process(target=foo)
    # p3 = Process(target=foo,name='rocky')

    p.start()
    # p2.start()
    # p3.start()
    print(p.is_alive()) # True
    time.sleep(5)
    print(p.is_alive()) # 代码运行完了就算死了 False
    # print(p.name)
    # print(p2.name)
    # print(p3.name)
    print('主')

仅作了解

from  multiprocessing import Process,current_process
import time
def foo():
    print('进程 start')
    # print('---------------------    ',current_process().name)
    time.sleep(50)
    print('进程 end')


if __name__ == '__main__':
    p = Process(target=foo)


    p.start()
    p.terminate() # 给操作系统发了一个请求
    print(p.is_alive()) # True
    p.join()
    print(p.is_alive()) # False

    print('主')

terminate方法是给操作系统下一个请求,直接结束进程的作用,谁调用,就结束谁。

守护进程

'''
守护进程
守护--》伴随
本质也是一个子进程
主进程的代码执行完毕守护进程直接结束。但是此时主进程可能没有结束.
'''

from multiprocessing import Process
import time
def foo():
    print('守护进程 start')
    time.sleep(5)
    print('守护进程 end')



if __name__ == '__main__':
    p = Process(target=foo)
    p.daemon = True # 把这个子进程定义为了守护进程
    p.start()
    time.sleep(2)
    print('主')

我感觉不到守护进程的作用,但是具体应用场景我们还没接触到,可能就是有这么一个业务需求,需要用守护进程来实现。听起来很牛逼的东西,其实就是你死,我也死。

posted @ 2019-09-14 23:53  chanyuli  阅读(109)  评论(0编辑  收藏  举报