Python进阶----进程间数据隔离, join阻塞等待, 进程属性, 僵尸进程和孤儿进程, 守护进程
一丶获取进程以及父进程的pid
含义:
进程在内存中开启多个,操作系统如何区分这些进程,每个进程都有一个唯一表示
方法三种方法:
一,终端查看所有pid tasklist
二,指定具体的PID tasklist | findstr python
三,代码查看pid os 模块
### 利用os 模块 查看 pid(当前进程id) 和 ppid(父进程id)
import os
import time
print('子进程pid:',os.getpid()) # 查看当前python程序的pid
print('父进程pid:',os.getppid()) #pycharm的pid
time.sleep(100)二丶验证进程之间的数据隔离
验证数据隔离
如果主进程中x的值是否改变,没有改变则说明父进程与子进程之间数据隔离
为什么进程之间数据不能共享.
开启两个程序 一个QQ,一个微信, 开启了两个进程.如果进程之间可以通信, 那QQ的进程是不是可以任意访问微信的数据. 这样会造成诸多问题. 所以,进程间理论上是不能通信的. 但是可以借助中间代理(队列)
# -*-coding:utf-8-*-
# Author:Ds
from multiprocessing import Process
x=1000
def task():
global x # 引用成全局变量
x=2 # 修改全局变量( 由于数据隔离,修改的数据只存在子进程中)
if __name__ == '__main__':
p1=Process(target=task,)
p1.start()
# 如果x的值没有改变,说明父进程与子进程之间数据隔离
print(f'主进程中的x的变量:{x}')
验证数据延用
只有数字能被沿用,范围:-5~256, 主进程子进程是沿用同一个.字符串等其他数据类型不延用
# -*-coding:utf-8-*-
# Author:Ds
from multiprocessing import Process
import time
x=100
def task():
print(f'子进程中:{id(x)}')
if __name__ == '__main__':
# 子进程与父进程之间的空间隔离., 要验证初始变量是否是一个id.
print(f'主进程中:{id(x)}')
p1=Process(target=task,)
p1.start()
time.sleep(3)
三丶join方法
含义:
join进程等待,等待主进程等待子进程结束之后再执行.不会被夯住(不会卡住)
### 并行 , 一共执行3秒. (前提是你已经创建3个子进程)
#原因:1. start方法 只是告诉主进程, 开启一个子线程.
# 2. join方法是等待
from multiprocessing import Process
import time
def task(name,sec):
print(f'{name}is running')
time.sleep(sec)
print(f'{name} is done')
if __name__ == '__main__':
start_time=time.time() #记录程序开始运行时间
p1=Process(target=task,args=('alex',1))
p2=Process(target=task,args=('abc',2))
p3=Process(target=task,args=('ds',3))
# 现在内存中几乎同时创建了3个子进程
# 随机性,创建子线程时间可能不同. 操作系统调用cpu先运行谁,谁先执行.
p1.start()
p2.start()
p3.start()
### 相当于: 现在内存中存在3个任务,同时进行,第一个任务执行1秒停顿, join方法,. 第二个任务已经执行了1秒,再执行1秒.over.第三个任务已经执行2秒停顿.再执行1秒.over.
p1.join() # 通知cpu 等待子进程执行完就执行主进程
p2.join() # 通知cpu 等待子进程执行完就执行主进程
p3.join() # 通知cpu 等待子进程执行完就执行主进程
### 以最时间长的为标准. 执行完子进程再执行父进程的打印.
print(f'执行总时长:{time.time()-start_time}')
### 总结: 三次start开启了三个通道.同时进行join 只是通知cpu要等待子进程执行完毕,再执行主进程
### for循环简化上述代码:
from multiprocessing import Process
import time
def task(name,sec):
print(f'{name}is running')
time.sleep(sec)
print(f'{name} is done')
if __name__ == '__main__':
start_time=time.time()
p_l=[] # 把子线程对象,放在列表中
for e in range(1,4):
e=Process(target=task,args=('alex',3))
e.start()
p_l.append(e)
for i in p_l:
i.join()
print(f'{time.time()-start_time}')
### join 串行
from multiprocessing import Process
import time
def task(name,sec):
print(f'{name} is running')
time.sleep(sec)
print(f'{name} is done')
if __name__ == '__main__':
start_time=time.time()
p1=Process(target=task,args=('alex',1))
p2=Process(target=task,args=('abc',2))
p3=Process(target=task,args=('ds',3))
p1.start() # 先创建p1 子进程并执行
p1.join() # 通知cpu 等待子进程执行完毕,再执行主进程
p2.start() # 等待p1执行完毕在开启p2进程
p2.join()
p3.start() # 等待p1.p2执行完毕在开启p3进程
p3.join()
# 最少6秒,还有系统调度cpu创建进程时间,往往高于6秒
print(f'执行总时长:{time.time()-start_time}')
### 总结: 一次 start 一次 join 相当于开了一个通道. 只能一次过以一辆车. join通知cpu等待子进程完成后才能继续执行主进程四丶进程对象的其他属性
常见的属性:
pid:获取子进程id
name:获取子进程name属性
terminate:杀死子进程
is_alive:查看子进程是否还活着
# -*-coding:utf-8-*-
# Author:Ds
from multiprocessing import Process
import time
def task():
print('子线程 is running')
if __name__ == '__main__':
p=Process(target=task,name='任务1')
p.start()
print(p.pid) # 获取子进程的pid
print(p.name) # 获取子进程的name属性
p.terminate() # 杀死进程 :通知操作系统执行当前任务(耗时)
time.sleep(1) # 由于is_alive存在主进程中.所以需要睡1秒之后再进行查看
print(p.is_alive())
print('主进程')
五丶僵尸进程与孤儿进程(存在Linux系统中)
进程了解:
每个进程退出时,内核释放应该进程所有的资源,但是还会保留一部分的信息,如:进程号,进程状态,运行时间.直到主进程利用这个waitepid()方法,才能够完全释放,回收子进程的资源
僵尸进程:(有害)
主进程(父进程)不能正常的使用waitepid()方法对子进程进行资源回收,这个状态是僵尸状态(Z状态).那么这部分的子进程就会成为僵尸进程
每一次子进程结束前,都会有一个僵尸状态.直到父进程调用waitepid()才会从僵尸态到消亡态
僵尸进程的害处:
僵尸进程的资源无法被释放,长期占用.内存压力增大.当新的程序来处理时,则会因为资源不足而导致运行失败.
kill -9 pid 是杀不死僵尸进程的,他能将进程的状态从正在运行态变成僵尸态,却不能将僵尸态的进程变为消亡态
# -*-coding:utf-8-*-
# Author:Ds
#### 父进程不能给子进程收尸 ,子进程就是僵尸进程
from multiprocessing import Process
import time
import os
def task(name):
print(f'{name} is running')
print(f'子进程开始了:{os.getpid()}')
time.sleep(50)
if __name__ == '__main__':
for i in range(100000):
p = Process(target=task,args=('怼哥',))
p.start()
print(f'\033[1;35;0m 主进程:{os.getpid()}\033[0m')孤儿进程:
父进程已经挂掉了,子进程还在运行.这个子进程就是孤儿进程. 孤儿进程会被'init'进程回收
from multiprocessing import Process
import time
import os
def task(name):
for i in range(20):
time.sleep(0.5)
print(f'子进程开始了:{os.getpid()}')
if __name__ == '__main__':
p = Process(target=task,args=('怼哥',))
p.start()
time.sleep(3)
print(f'\033[1;35;0m 主进程:{os.getpid()}\033[0m')
# 父进程 正常对退出,子进程还有自己的事情没有干完. 所以子进程成为孤儿进程六丶守护进程
含义:
守护进程本身是一个子进程,守护的主进程
结束条件:主进程代码结束了,守护进程也就结束了
### 守护进程也属于子进程,主进程代码结束前结束.因为主进程要回收子进程的资源
# 1. 主进程的代码结束,守护进程结束
# 2. 主进程要回收守护进程(子进程)的资源
# 3. 等待其他所有子进程结束
# 4. 主进程回收所有子进程资源# -*-coding:utf-8-*-
# Author:Ds
from multiprocessing import Process
import time
import os
def task(name):
for i in range(20):
time.sleep(0.5)
print(f'子进程开始了:{os.getpid()}')
def func2():
print('start:func2')
time.sleep(5)
print('end:func2')
if __name__ == '__main__':
start_time=time.time()
p = Process(target=task,args=('怼哥',))
p.daemon=True # 设置为守护进程
p.start()
Process(target=func2).start()
print('in main')
time.sleep(3)
print(f'主进程开始了:{os.getpid()} ,结束时间{time.time()-start_time}')
### 一个py文件相当于开启了一个进程 ,这是一个主进程.
# 主进程会等待所有的非守护进程运行完毕才结束哦 --->?为什么? 因为主进程要对所有的子进程进行资源回收
# 守护进程守护是什么? 是主进程的'代码运行完毕'. 守护进程就结束了.
# 个人理解: 主进程会等待所有的非守护进程的子进程执行完毕. 连同守护进程的资源统一回收.
##################################################################################################
### 为什么要有主进程等待子进程结束之后才结束呢?
# 1.因为主进程负责给子进程回收一些系统资源
### 守护进程:本身是一个子进程,守护的主进程
# 结束条件:主进程代码结束了,守护进程也就结束了
### 进程
# 主进程的代码结束,守护进程结束
# 主进程要回收守护进程(子进程)的资源
# 等待其他所有子进程结束
# 主进程回收所有子进程资源