pythonNET day05

孤儿进程

父进程先于子进程退出，此时子进程就会成为孤儿进程。

　　孤儿进程会被系统指定的进程收养，即系统进程会成为该孤儿进程新的父进程。孤儿进程退出时该父进程会处理退出状态

僵尸进程

子进程先于父进程退出，父进程没有处理子进程退出状态，此时子进程会成为僵尸进程

　　* 僵尸进程已经结束，但是会滞留部分PCB信息的内存，大量的僵尸会消耗系统的内存资源，应该尽量避免

如何避免僵尸进程的产生：

父进程处理子进程的退出状态

pid,status = os.wait()

功能：在父进程中阻塞等待处理子进程的退出

返回值：pid　　退出的子进程的PID号

　　　　status　　子进程的退出状态

 1 import os,sys 
 2 from time import sleep
 3 
 4 pid = os.fork()
 5 
 6 if pid < 0:
 7     print("create process failed")
 8 elif pid == 0:
 9     sleep(3)
10     print("子进程ＰＩＤ:",os.getpid())    # 子进程ＰＩＤ: 4150
11     sys.exit(3)
12 else: 
13     #等待子进程退出
14     pid,status = os.wait()
15     print(pid,status)   # 4150 768
16     print(os.WEXITSTATUS(status)) #获取退出状态  3
17     while True:
18         pass

pid,status = os.wait()

pid,status = os.waitpid(pid,option)

功能：同wait

参数：pid　　-1　　表示任意子进程退出

　　　　　　 >0　　整数　　指定PID号的子进程

　　option　　0　　　　表示阻塞等待

　　　　　　os.WNOHANG　　表示非阻塞

返回值：同wait

waitpid(-1,0)　　= => wait()　

 1 import os,sys 
 2 from time import sleep
 3 
 4 pid = os.fork()
 5 
 6 if pid < 0:
 7     print("create process failed")
 8 elif pid == 0:
 9     sleep(3)
10     print("子进程ＰＩＤ:",os.getpid())
11     sys.exit(3)
12 else: 
13     #等待子进程退出
14     while True:    # 不断地循环监听
15         sleep(1)
16         pid,status = os.waitpid(-1,os.WNOHANG)    # -1等待任意子进程退出 非阻塞
17         print(pid,status)
18         if os.WEXITSTATUS(status):    # >0 如果WIFEXITED非零，返回子进程退出码
19             break
20         print("do something others")
21     while True:
22         pass
23 
24 # 0 0
25 # do something others
26 # 0 0
27 # do something others
28 # 子进程ＰＩＤ: 4698
29 # 0 0
30 # do something others
31 # 4698 768

pid,status = os.waitpid(-1,os.WNOHANG)

父进程先退出

创建二级子进程

　　1、父进程创建子进程等待子进程退出

　　2、子进程创建二级子进程，然后马上退出

　　3、二级子进程成为孤儿，处理具体事件

 1 # 创建二级子进程处理僵尸进程
 2 import os 
 3 from time import sleep 
 4 
 5 def fun1():
 6     sleep(3)
 7     print("第一件事情")
 8 
 9 def fun2():
10     sleep(4)
11     print("第二件事情")
12 
13 pid = os.fork()
14 
15 if pid < 0:
16     print("Create process error")
17 elif pid == 0:    # 子进程 
18     # 创建二级进程
19     pid0 = os.fork()
20     if pid0 < 0:
21         print("创建二级进程失败")
22     elif pid0 == 0:    # 子子进程
23         fun2()  # 做第二件事
24     else:    # 子进程
25         os._exit(0)    # 二级进程退出
26 else:
27     os.wait()
28     fun1() # 做第一件事
29 
30 # tarena@tedu:~/桌面$ python3 1.py
31 # 第一件事情
32 # tarena@tedu:~/桌面$ 第二件事情

创建二级子进程处理僵尸进程

multiprocessing 模块创建进程

1. 需要将要做的事情封装成函数
2. 使用multiprocessing提供的类Process创建进程对象
3. 通过进程对象和Process初始化进程进行进程的设置，绑定函数
4. 启动进程，会自动执行绑定的函数
5. 完成进程的回收

创建进程对象
Process()　　创建进程对象
参数： target ：要绑定的函数
name ：给进程起的名称（默认Process-1）
args：元组用来给target函数位置传参
kwargs : 字典用来给target函数键值传参

p.start()
功能：启动进程自动运行terget绑定函数。此时进程被创建

p.join([timeout])
功能：阻塞等待子进程退出
参数：超时时间

* 使用multiprocessing创建进程子进程同样复制父进程的全部内存空间，之后有自己独立的空间，执行上互不干扰
* 子进程也是有自己特有的PID等资源
* 如果不使用join回收可能会产生僵尸进程
* 使用multiprocessing创建子进程，一般父进程功能就是创建子进程回收子进程，所有事件交给子进程完成

 1 import multiprocessing as mp 
 2 from time import sleep 
 3 import os
 4 
 5 a = 1
 6 
 7 def fun():
 8     sleep(2)
 9     print("子进程事件",os.getpid())
10     global a
11     a = 10000
12     print("a = ",a)
13 
14 p = mp.Process(target = fun)    # 创建进程对象
15 p.start()   # 启动进程
16 sleep(3)
17 print("这是父进程")
18 p.join()    # 回收进程
19 print("parent a:",a)
20 
21 # 子进程事件 5434
22 # a =  10000
23 # 这是父进程
24 # parent a: 1