并发编程----pid 数据隔离 jion 属性 僵尸孤儿 守护进程
pid 数据隔离 jion 属性 僵尸孤儿 守护进程
一,multiprocessing模块
- python中的多线程无法利用多核优势,如果想要充分地使用多核CPU的资源(os.cpu_count()查看),在python中大部分情况需要使用多进程.Python提供了multiprocessing.
- multiprocessing模块用来开启子进程,并在子进程中执行我们定制的任务(比如函数),该模块与多线程模块threading的编程接口类似.
- multiprocessing模块的功能众多: 支持子进程、通信和共享数据、执行不同形式的同步,提供了Process、Queue、Pipe、Lock等组件.
- 需要再次强调的一点是: 与线程不同,进程没有任何共享状态,进程修改的数据,改动仅限于该进程内.
二, Process类的介绍
-
创建进程的类:
Process([group [, target [, name [, args [, kwargs]]]]])，由该类实例化得到的对象，表示一个子进程中的任务（尚未启动） 强调： 1. 需要使用关键字的方式来指定参数 2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号 -
参数介绍:
- group参数未使用,值始终为None
- target表示调用对象,即子进程要执行的任务
- args表示调用对象的位置参数元组
- kwargs表示调用对象的字典
- name为子进程的名称
-
方法介绍:
- p.start(): 启动进程,并调用该子进程的p.run()
- p.run(): 进程启动时运行的方法,正是它去调用target指定的函数,我们自定义类的类中一定要实现该方法
- p.terminate(): 强制终止进程p,不会进行任何清理操作,如果p创建了子进程,该子进程就成了僵尸进程,使用该方法需要特别小心这种情况.如果p还保存了一个锁那么也将不会被释放,进而导致死锁
- p.is_alive(): 如果p仍然运行,返回True
- p.join([timeout]): 主线程等待p终止(强调: 是主线程处于等的状态,而p是处于运行的状态).timeout是可选的超时时间,需要强调的是,p.join只能join住start开启的进程,而不能join住run开启的进程.阻塞
-
属性介绍:
-
p.daemon: 默认值为False,如果设为True,代表p为后台运行的守护进程,当p的父进程终止时,p也随之终止,并且设定为True后,p不能创建自己的新进程,必须在p.start()之前设置
-
p.name: 进程的名称
-
p.pid: 进程的pid
-
进程在内存中开启多个,操作系统如何区分这些进程,每个进程都有一个唯一标识
# 在终端查看进程的pid tasklist(查看现阶段运行的所有进程) # 一个程序可以有多个进程 # 在终端查看指定的进程的pid tasklist| findstr pycharm # 通过代码查看pid import os print(os.getpid()) # 当前进程id print(os.getppid()) # 查看父进程id
-
-
-
p.ppid: 父进程的pid
三, Process类的使用
一,创建开启子进程的两种方式
# 开启进程的2种方式
# 第一种方式
from multiprocessing import Process
import time
def task(name):
print(f'{name} is running')
time.sleep(9)
print(f'{name} is done')
if __name__ == '__main__': # windows必须在main下开启多进程
p = Process(target=task, args=('子进程',)) # args一定是一个元组
p.start() # 通知操作系统在内存种开辟一个空间,将p这个进程放进去,让cpu执行
print('===>主进程')
----------------------------------------------------
# 第二种方式
from multiprocessing import Process
import time
class MyProcess(Process):
def __init__(self, name):
super().__init__() # 必须继承父类的init
self.name = name
def run(self): # 必须是run
print(f'{self.name} is running')
time.sleep(9)
print(f'{self.name} is done')
if __name__ == '__main__':
p = MyProcess('子进程')
p.start()
print('===>主进程')
二,验证进程之间的空间隔离
from multiprocessing import Process
import time
x = 1000
def task():
global x
x = 2
if __name__ == '__main__':
p1 = Process(target=task)
p1.start()
time.sleep(3)
print('主进程:', x)
# 验证了数据隔离
# 只有数字-5~256,True,False在不同进程之间驻留,沿用同一个内存地址
三.进程对象的join方法
from multiprocessing import Process
import time
def task():
print('子进程开始')
time.sleep(3)
print('子进程结束')
if __name__ == '__main__':
p1 = Process(target=task)
p1.start()
time.sleep(4)
print(' in 主进程')
# 上面的版本虽然达到了目的,但是真正的生产环境中,子进程结束的时间不定,需要用到join
-------------------------------------------------------
from multiprocessing import Process
import time
def task():
print('子进程开始')
time.sleep(3)
print('子进程结束')
if __name__ == '__main__':
p1 = Process(target=task)
p1.start()
p1.join() # 告知主进程,p1进程结束之后,主进程再运行
print(' in 主进程')
-------------------------------------------------------
# 开启多个子进程去验证
from multiprocessing import Process
import time
def task(n):
print(f'{n}子进程开始')
time.sleep(n)
print(f'{n}子进程结束')
if __name__ == '__main__':
time_start = time.time()
p1 = Process(target=task, args=(1,))
p2 = Process(target=task, args=(2,))
p3 = Process(target=task, args=(3,))
p1.start()
p2.start()
p3.start()
p1.join()
p2.join()
p3.join()
print(f'主进程在{time.time() - time_start}后执行')
# 验证了如此写join并不是串行,主进程会等最长的结束再执行
# p1,p2,p3谁先运行并不确定
------------------------------------------------------
# 下面的结果是什么? 为什么?
from multiprocessing import Process
import time
def task(n):
print(f'{n}子进程开始')
time.sleep(n)
print(f'{n}子进程结束')
if __name__ == '__main__':
time_start = time.time()
p1 = Process(target=task, args=(1,))
p2 = Process(target=task, args=(2,))
p3 = Process(target=task, args=(3,))
p1.start()
p1.join()
print(111)
p2.start()
p2.join()
print(222)
p3.start()
p3.join()
print(333)
print(f'主进程在{time.time() - time_start}后执行')
# p1,p2,p3是串行
-------------------------------------------------------------------------------------
from multiprocessing import Process
import time
def task(n):
print(f'{n}子进程开始')
time.sleep(n)
print(f'{n}子进程结束')
if __name__ == '__main__':
time_start = time.time()
lst = []
for el in range(1, 4):
p = Process(target=task, args=(el,))
lst.append(p)
p.start()
for p in lst:
p.join()
print(f'主进程在{time.time() - time_start}后执行')
四.进程对象的其他属性
from multiprocessing import Process
import time
def task():
print('子进程开始')
time.sleep(3)
print('子进程结束')
if __name__ == '__main__':
p1 = Process(target=task, name='任务1') # name给进程对象设置name属性
p1.start()
print(p1.pid) # 获取进程的pid号
print(p1.name)
p1.terminate() # 终止(杀死)子进程,强制结束
# terminate 与 start一样的工作原理:
# 都是通知操作系统终止或开启一个子进程,内存中终止或开启,
# 这是需要耗费时间的
time.sleep(1)
print(p1.is_alive()) # 判断子进程是否存活
# is_alive 只是查看内存中子进程是否在运行
print('In 主进程')
五.僵尸进程和孤儿进程
# 僵尸进程
from multiprocessing import Process
import time
import os
def task():
print(f'子进程开始了:{os.getpid()}')
time.sleep(50)
print('子进程结束')
if __name__ == '__main__':
p1 = Process(target=task)
p1.start()
print(f'主进程开始了:{os.getpid()}')
# 主进程是子进程的发起者,按理说,主进程不会管子进程是否结束,对于结束来说,两个进程是没有任何关系的.
# 但是通过代码发现: 主进程并没有结束,实际上主进程要等到所有子进程结束之后,才会结束
# 所以此时的主进程就称之为: 僵尸进程
# 主进程此时的内存中只包含: 主进程的pid,以及子进程的开启时间,结束时间,至于主进程的代码以及文件,数据库等等全部消失
# 因为主进程要进行收尸环节:
# 利用waitepid()方法,对所有的结束的子进程进行回收
# 孤儿进程: 此时如果主进程由于各种原因,提前消失,它下面的所有子进程都称为孤儿进程
# 谁给孤儿进程收尸? 一段时间之后,init就会对孤儿进程进行回收
# 孤儿进程无害,如果僵尸进程挂了,init会对孤儿进程进行回收
# 僵尸进程是有害的,假如僵尸进程无限的开启子进程,递归的开启,子进程越来越多,僵尸进程还有没有结束,都不会回收,导致进程越来越多,占用内存
六.守护进程
- 守护进程会在主进程代码执行结束后就终止
- 守护进程内无法再开启子进程
# 子进程对父进程可以进行守护
from multiprocessing import Process
import time
import os
def task():
print(f'子进程开始了:{os.getpid()}')
time.sleep(50)
print('子进程结束')
if __name__ == '__main__':
p1 = Process(target=task)
p1.daemon = True # 将p1子进程设置成守护进程,守护主进程
# 只要主进程结束,子进程无论执行到哪,都会马上结束
# 一定要在start之前
p1.start()
print(f'主进程开始了:{os.getpid()}')
