进程进阶

孤儿进程（亚索进程）

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

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

就是一个子进程的父进程挂掉的时候，这个子进程就会成为一个孤鹅，他将会被一个叫做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('主')

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