multiprocess模块
一. Process模块介绍
1. 直接使用Process模块创建进程
(1)主进程和子进程
(2)if __name__ == "main"语句
2. Process模块参数介绍
函数传参的两种方式
3. Process模块方法介绍
(1)join方法的使用
(2)for循环开启多个进程
4. Process模块属性介绍
5. 在windows中必须把Process()放到if __name__ == "main"语句下
二. Process类的使用
1. 继承的形式创建进程
2. 进程的内存空间是隔离的
3. Process对象的其他方法或属性
terminate, is_alive, 显示进程名和id
4. 子进程中不能有input
5. 僵尸进程和孤儿进程
三. 守护进程
multiprocess模块
仔细说来，multiprocess不是一个模块而是python中一个操作、管理进程的包。 之所以叫multi是取自multiple的多功能的意思,在这个包中几乎包含了和进程有关的所有子模块。由于提供的子模块非常多，为了方便大家归类记忆，我将这部分大致分为四个部分：创建进程部分，进程同步部分，进程池部分，进程之间数据共享。重点强调：进程没有任何共享状态，进程修改的数据，改动仅限于该进程内，但是通过一些特殊的方法，可以实现进程之间数据的共享。
一. Process模块介绍
1. 直接使用Process模块创建进程
Process模块是一个创建进程的模块,借助这个模块,就可以完成进程的创建.
Process([group [, target [, name [, args [, kwargs]]]]])，由该类实例化得到的对象，表示一个子进程中的任务（尚未启动） 强调： 1. 需要使用关键字的方式来指定参数 2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号
举例说明:
# 当前文件名称为test.py
# 引入Process模块
from multiprocessing import Process
def func():
print("子进程正在运行")
if __name__ == ‘__main__‘:
"""由于系统创建进程机制的原因,windows下必须
写if __name__ == ‘__main__‘语句"""
p = Process(target=func,)
"""这一步骤将函数注册到一个进程中,p是一个进程对象,
此时还没有启动进程,只是创建了一个进程对象.
这里的func是不加括号的,因为加上括号函数就直接运行了"""
p.start()
"""这一步骤告诉操作系统,给我开启一个进程,此时func函数
就被我们新开启的这个进程执行了,而这个进程是我主进程运
行过程中创建出来的,所以这个新创建的进程为主进程的子进程,
主进程又可以称为这个新进程的父进程"""
print("主进程执行完毕")
"""这是主进程的程序,上面开启的子进程的程序是和主进程的
程序同时运行的,我们称为异步"""
举例说明
(1)主进程和子进程
上面说了，我们通过主进程创建的子进程是异步执行的，那么我们就验证一下，并且看一下子进程和主进程(也就是父进程)的ID号（讲一下pid和ppid，使用pycharm举例），来看看是否是父子关系。
import time
import os
# os.getpid() 获取自己进程的ID号
# os.getppid() 获取自己进程的父进程的ID号
from multiprocessing import Process
def func():
print("*"*10)
time.sleep(1)
print("子进程ID>>>", os.getpid())
print("子进程的父进程ID>>>", os.getppid())
print("~"*10)
if __name__ == ‘__main__‘:
p = Process(target=func,)
p.start()
print("@"*10)
print("父进程ID>>>", os.getpid())
print("父进程的父进程ID>>>", os.getppid())
print("#"*10)
# @@@@@@@@@@
# 父进程ID>>> 9040
# 父进程的父进程ID>>> 6328
# ##########
# **********
# 子进程ID>>> 6872
# 子进程的父进程ID>>> 9040
# ~~~~~~~~~~
举例说明
从以上实例可以看出,首先打印出来的是主进程的ID号,然后打印的是子进程的ID号,也就是子进程是异步执行的,相当于主进程和子进程同时运行着.如果是同步的话,我们先执行的是func(),应该是子进程的ID先打印出来.显然,这与实际结果是矛盾的.于是可以得出"主进程创建的子进程是异步执行"这样的结论.
(2)if __name__ == "main"语句
在Windows操作系统中由于没有fork(linux操作系统中创建进程的机制)，在创建子进程的时候会自动 import 启动它的这个文件，而在 import 的时候又执行了整个文件。因此如果将process()直接写在文件中就会无限递归创建子进程报错。所以必须把创建子进程的部分使用if __name__ ==‘__main__’ 判断保护起来，import 的时候就不会递归运行了。
2. Process模块参数介绍
参数介绍：
1 group参数未使用，值始终为None
2 target表示调用对象，即子进程要执行的任务
3 args表示调用对象的位置参数元组，args=(1,2,‘egon‘,)
4 kwargs表示调用对象的字典,kwargs={‘name‘:‘egon‘,‘age‘:18}
5 name为子进程的名称
函数传参的两种方式:
import time
from multiprocessing import Process
def func(a, b, c):
print("函数func的参数分别是>>>", a, b, c)
print("子进程执行完毕!")
if __name__ == ‘__main__‘:
p = Process(target=func, args=("参数一", "参数二", "参数三"))
p.start()
time.sleep(1)
print("主进程执行完毕!")
# 执行结果是:
# 函数func的参数分别是>>> 参数一 参数二 参数三
# 子进程执行完毕!
# 主进程执行完毕!
函数传参的第一种方式
import time
from multiprocessing import Process
def func(a, b, c):
print("函数func的参数分别是>>>", a, b, c)
print("子进程执行完毕!")
if __name__ == ‘__main__‘:
p = Process(target=func, kwargs={"a":"参数一", "b":"参数二", "c":"参数三"})
p.start()
time.sleep(1)
print("主进程执行完毕!")
# 执行结果:
# 函数func的参数分别是>>> 参数一 参数二 参数三
# 子进程执行完毕!
# 主进程执行完毕!
函数传参的第二种方式
3. Process模块方法介绍
1 p.start()：启动进程，并调用该子进程中的p.run() 2 p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法 3 p.terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁 4 p.is_alive():如果p仍然运行，返回True 5 p.join([timeout]):主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程
(1)join方法的使用
import time
from multiprocessing import Process
def func():
print("子进程开始执行!")
time.sleep(1)
print("子进程执行完毕!")
if __name__ == ‘__main__‘:
print("主进程开始执行!")
p = Process(target=func,)
p.start()
print("主进程执行完毕!")
# 执行结果:
# 主进程开始执行!
# 主进程执行完毕!
# 子进程开始执行!
# 子进程执行完毕!
实例1
import time
from multiprocessing import Process
def func():
print("子进程开始执行!")
time.sleep(1)
print("子进程执行完毕!")
if __name__ == ‘__main__‘:
print("主进程开始执行!")
p = Process(target=func, )
p.start()
p.join()
print("主进程执行完毕!")
# 执行结果:
# 主进程开始执行!
# 子进程开始执行!
# 子进程执行完毕!
# 主进程执行完毕!
实例2
对比实例1和实例2的结果,可以发现,实例1的打印结果明显不符合正常的代码执行流程,竟然是:主进程开启并结束之后,子进程才开启并结束.出现这样的情况的原因是: 主进程开启后,随即便调用操作系统创建子进程(p = Process(target=func,))并开启子进程(p.start()). 然而,在创建和执行子进程的过程中,操作系统要进行相当复杂的操作(如分配资源),这些操作都是需要时间的,从而造成了主进程先于子进程执行完毕的现象.
但是join()方法可以完美地解决这个问题.在实例2中,当主进程执行到p.join()时,整个程序会阻塞在这里,直到子进程p执行完毕,主进程才能继续向下执行,也就不会出现主进程先于子进程执行完毕的现象了.
(2)for循环开启多个进程
from multiprocessing import Process
def func(n):
print(n)
if __name__ == ‘__main__‘:
for i in range(10):
p = Process(target=func, args=(i,))
p.start()
print("主进程执行完毕!")
# 执行结果:
# 0
# 2
# 1
# 3
# 4
# 主进程执行完毕!
# 5
# 6
# 7
# 8
# 9
实例1
from multiprocessing import Process
def func(n):
print(n)
if __name__ == ‘__main__‘:
pro_list = []
for i in range(10):
p = Process(target=func, args=(i,))
p.start()
pro_list.append(p)
for p in pro_list:
p.join()
print("主进程结束!")
# 执行结果:
# 1
# 0
# 3
# 2
# 4
# 5
# 6
# 7
# 8
# 9
# 主进程结束!
实例1优化
模拟两个应用场景: 1.同时对一个文件进行写操作 2.同时创建多个文件
import time
import os
import re
from multiprocessing import Process
#多进程同时对一个文件进行写操作
def func(x,y,i):
with open(x,‘a‘,encoding=‘utf-8‘) as f:
print(‘当前进程%s拿到的文件的光标位置>>%s‘%(os.getpid(),f.tell()))
f.write(y)
#多进程同时创建多个文件
# def func(x, y):
# with open(x, ‘w‘, encoding=‘utf-8‘) as f:
# f.write(y)
if __name__ == ‘__main__‘:
p_list= []
for i in range(10):
p = Process(target=func,args=(‘can_do_girl_lists.txt‘,‘姑娘%s‘%i,i))
# p = Process(target=func,args=(‘can_do_girl_info%s.txt‘%i,‘姑娘电话0000%s‘%i))
p_list.append(p)
p.start()
[ap.join() for ap in p_list] #这就是个for循环，只不过用列表生成式的形式写的
with open(‘can_do_girl_lists.txt‘,‘r‘,encoding=‘utf-8‘) as f:
data = f.read()
all_num = re.findall(‘\d+‘,data) #打开文件，统计一下里面有多少个数据，每个数据都有个数字，所以re匹配一下就行了
print(‘>>>>>‘,all_num,‘.....%s‘%(len(all_num)))
#print([i in in os.walk(r‘你的文件夹路径‘)])
print(‘不要钱~~~~~~~~~~~~~~~~！‘)
两个应用场景
4. Process模块方法介绍
1 p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置 2 p.name:进程的名称 3 p.pid：进程的pid 4 p.exitcode:进程在运行时为None、如果为–N，表示被信号N结束(了解即可) 5 p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）
5. 在windows中必须把Process()放到if __name__ == "main"语句下
由于Windows没有fork，多处理模块启动一个新的Python进程并导入调用模块。 如果在导入时调用Process（），那么这将启动无限继承的新进程（或直到机器耗尽资源）。 这是隐藏对Process（）内部调用的原，使用if __name__ == “__main __”，这个if语句中的语句将不会在导入时被调用。
二. Process类的使用
1. 继承的形式创建进程
# 自定义一个类,继承Process类,必须写一个run()方法.如果想要传参,可以自己写一个init方法,然后首先执行super父类的init方法,再写自己的属性.
from multiprocessing import Process
class MyProcess(Process): # 自定义的类要继承Process类
def __init__(self, n, name):
super().__init__() # 如果自己想要传参name, 那么要首先用super()执行父类的init方法
self.n = n
self.name = name
def run(self):
print("子进程的名字是>>>", self.name)
print("n的值是>>>", self.n)
if __name__ == ‘__main__‘:
p1 = MyProcess(123, name="子进程01")
p1.start() # 给操作系统发送创建进程的指令,子进程创建好之后,要被执行,执行的时候就会执行run方法
print("p1.name是>>>", p1.name)
print("主进程结束")
# 执行结果:
# p1.name是>>> 子进程01
# 主进程结束
# 子进程的名字是>>> 子进程01
# n的值是>>> 123
类继承的方式创建进程
2. 进程的内存空间是隔离的
import time
from multiprocessing import Process
global_num = 100
def func(): # 子进程
global global_num
global_num = 0
print("子进程的全局变量>>>", global_num)
if __name__ == ‘__main__‘:
p1 = Process(target=func,)
p1.start()
time.sleep(1) # 等待子进程执行结束
print("主进程的全局变量>>>", global_num)
# 执行结果:
# 子进程的全局变量>>> 0
# 主进程的全局变量>>> 100
# 得出结论:
# 进程之间是空间隔离的,不共享资源
验证进程之间是空间隔离的
3. Process对象的其他方法或属性
from multiprocessing import Process
import time
def func():
print("子进程开始执行!")
time.sleep(2)
print("子进程执行完毕!")
if __name__ == ‘__main__‘:
p = Process(target=func,)
p.start()
p.terminate() # 给操作系统发送一个关闭进程p1的信号,让操作系统去关闭它
time.sleep(1)
"""由于操作系统关闭子进程的过程需要做许多事情(如回收资源),这是需要耗费一定时间的,
如果在给操作系统发出关闭信号后(p1.terminate())立刻判断子进程是否还活着,结果是不准
确的,此时操作系统正在关闭子进程,所以我们要等待一定时间才可以得到正确的判断结果."""
print("子进程是否还活着>>>", p.is_alive())
print("主进程执行完毕!")
terminate和is_alive
from multiprocessing import Process
def func():
print("子进程开始执行!")
if __name__ == ‘__main__‘:
p = Process(target=func,)
p.start()
p.join()
print("子进程的ID是>>>", p.pid)
print("子进程的名字是>>>", p.name)
print("主进程执行完毕!")
# 执行结果:
# 子进程开始执行!
# 子进程的ID是>>> 4292
# 子进程的名字是>>> Process-1
# 主进程执行完毕!
进程名和进程ID
4. 子进程中不能有input
如果在子进程中存在input,由于输入台只显示在主进程中,子进程是没有输入台的,于是系统会自动报错.所以不要在子进程中出现input.
5. 僵尸进程和孤儿进程
(1)僵尸进程(有害):
任何一个子进程(init除外)在exit()之后，并非马上就消失掉，而是留下一个称为僵尸进程(Zombie)的数据结构，等待父进程处理。这是每个子进程在结束时都要经过的阶段。如果子进程在exit()之后，父进程没有来得及处理，这时用ps命令就能看到子进程的状态是“Z”。如果父进程能及时 处理，可能用ps命令就来不及看到子进程的僵尸状态，但这并不等于子进程不经过僵尸状态。 如果父进程在子进程结束之前退出，则子进程将由init接管。init将会以父进程的身份对僵尸状态的子进程进行处理。
例如有个进程，它定期的产 生一个子进程，这个子进程需要做的事情很少，做完它该做的事情之后就退出了，因此这个子进程的生命周期很短，但是，父进程只管生成新的子进程，至于子进程 退出之后的事情，则一概不闻不问，这样，系统运行上一段时间之后，系统中就会存在很多的僵死进程，倘若用ps命令查看的话，就会看到很多状态为Z的进程。 严格地来说，僵死进程并不是问题的根源，罪魁祸首是产生出大量僵死进程的那个父进程。因此，当我们寻求如何消灭系统中大量的僵死进程时，答案就是把产生大 量僵死进程的那个元凶枪毙掉（也就是通过kill发送SIGTERM或者SIGKILL信号啦）。枪毙了元凶进程之后，它产生的僵死进程就变成了孤儿进 程，这些孤儿进程会被init进程接管，init进程会wait()这些孤儿进程，释放它们占用的系统进程表中的资源，这样，这些已经僵死的孤儿进程 就能瞑目而去了。
僵尸进程危害场景
(2)孤儿进程(无害)
孤儿进程：一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养，并由init进程对它们完成状态收集工作。孤儿进程是没有父进程的进程，孤儿进程这个重任就落到了init进程身上，init进程就好像是一个民政局，专门负责处理孤儿进程的善后工作。每当出现一个孤儿进程的时候，内核就把孤 儿进程的父进程设置为init，而init进程会循环地wait()它的已经退出的子进程。这样，当一个孤儿进程凄凉地结束了其生命周期的时候，init进程就会代表党和政府出面处理它的一切善后工作。因此孤儿进程并不会有什么危害。
三. 守护进程
使用平常的方法时,子进程是不会随着主进程的结束而结束,只有当主进程和子进程全部执行完毕后,程序才会结束.但是,如果我们的需求是: 主进程执行结束,由该主进程创建的子进程必须跟着结束. 这时,我们就需要用到守护进程了.
主进程创建守护进程:
其一: 守护进程会在主进程代码执行结束后就终止
其二:守护进程内无法再开启子进程,否则抛出异常: AssertionError: daemonic processes are not allowed to have children
需要注意的是: 进程之间是相互独立的,主进程代码运行结束,守护进程随机终止.
import os
import time
from multiprocessing import Process
class Myprocess(Process):
def __init__(self,person):
super().__init__()
self.person = person
def run(self):
print("这个人的ID号是:%s" % os.getpid())
print("这个人的名字是:%s" % self.name)
time.sleep(3)
if __name__ == ‘__main__‘:
p=Myprocess(‘李华‘)
p.daemon=True #一定要在p.start()前设置,设置p为守护进程,禁止p创建子进程,并且父进程代码执行结束,p即终止运行
p.start()
# time.sleep(1) # 在sleep时linux下查看进程id对应的进程ps -ef|grep id
print(‘主进程执行完毕!‘)
守护进程
原文地址：https://www.cnblogs.com/haitaoli/p/9837697.html