标签：大量 start 进程启动 元组 两种 严格 方法 kill 16px
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不是一个模块而是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("主进程执行完毕!") # 执行结果: # 主进程开始执行! # 主进程执行完毕! # 子进程开始执行! # 子进程执行完毕!
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("主进程执行完毕!") # 执行结果: # 主进程开始执行! # 子进程开始执行! # 子进程执行完毕! # 主进程执行完毕!
对比实例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
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.同时对一个文件进行写操作 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("主进程执行完毕!")
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 # 主进程执行完毕!
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(‘主进程执行完毕!‘)
标签：大量 start 进程启动 元组 两种 严格 方法 kill 16px
原文地址：https://www.cnblogs.com/haitaoli/p/9837697.html
