multiprocess不是一个模块而是python中一个操作、管理进程的包，几乎包含了和进程有关的所有子模块。大致分为四类：
- 创建进程部分
- 进程同步部分
- 进程池部分
- 进程之间数据共享
class Process(object): def __init__(self, group=None, target=None, name=None, args=(), kwargs={}): self.name = '' self.daemon = False self.authkey = None self.exitcode = None self.ident = 0 self.pid = 0 self.sentinel = None def run(self): pass def start(self): pass def terminate(self): pass def join(self, timeout=None): pass def is_alive(self): return False
从pycharm点开源码，我么可以看到：
Process([group [, target [, name [, args [, kwargs]]]]]) group参数未使用，值始终为None name为子进程的名称 target表示调用对象，即子进程要执行的任务 下面两个是target的参数 args表示调用对象的位置参数元组，args=(1,2) kwargs表示调用对象的字典,kwargs={'a':1,'b':2} 强调： 1. 需要使用关键字的方式来指定参数 2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号
p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置
p.name:进程的名称
p.pid：进程的pid
p.exitcode:进程在运行时为None、如果为–N，表示被信号N结束(了解即可)
p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）
属性介绍
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开启的进程
方法介绍
注意事项：
在Windows操作系统中由于没有fork(linux操作系统中创建进程的机制)，在创建子进程的时候会自动 import 启动它的这个文件，而在 import 的时候又执行了整个文件。
因此如果将process()直接写在文件中就会无限递归创建子进程报错。所以必须把创建子进程的部分使用if __name__ =='__main__' 判断保护起来，import 的时候 ，就不会递归运行了。
创建和调用
import time from multiprocessing import Process def f(name): print("子进程"+name+"开始") time.sleep(10) print('子进程结束') if __name__ == '__main__': p = Process(target=f, args=('1',)) p.start() # p.join() print('我是父进程')
子进程1开始
子进程结束
我是父进程
import os import time import random from multiprocessing import Process def f(x): print(x,'子进程id 开始：',os.getpid(),'父进程id ：',os.getppid()) time.sleep(random.random()*5) print(x, '子进程id 结束：', os.getpid(), '父进程id ：', os.getppid()) return x if __name__ == '__main__': print('主进程id ：', os.getpid()) p_lst = [] for i in range(5): p = Process(target=f, args=(i,)) p.start()
主进程id ： 9524 0 子进程id 开始： 7800 父进程id ： 9524 2 子进程id 开始： 7392 父进程id ： 9524 1 子进程id 开始： 3780 父进程id ： 9524 3 子进程id 开始： 19452 父进程id ： 9524 4 子进程id 开始： 14484 父进程id ： 9524 1 子进程id 结束： 3780 父进程id ： 9524 0 子进程id 结束： 7800 父进程id ： 9524 3 子进程id 结束： 19452 父进程id ： 9524
join
两种用法
1.每层循环启动的时候，都单个进程join加入，会发生 进程“完全串行”的状况
import os import time import random from multiprocessing import Process def f(x): print(x,'子进程id 开始：',os.getpid(),'父进程id ：',os.getppid()) time.sleep(random.random()*5) print(x, '子进程id 结束：', os.getpid(), '父进程id ：', os.getppid()) return x if __name__ == '__main__': print('主进程id ：', os.getpid()) for i in range(5): p = Process(target=f, args=(i,)) p.start() p.join() print("我是父进程")
主进程id ： 10040 0 子进程id 开始： 11508 父进程id ： 10040 0 子进程id 结束： 11508 父进程id ： 10040 1 子进程id 开始： 9136 父进程id ： 10040 1 子进程id 结束： 9136 父进程id ： 10040 2 子进程id 开始： 18332 父进程id ： 10040 2 子进程id 结束： 18332 父进程id ： 10040 3 子进程id 开始： 104 父进程id ： 10040 3 子进程id 结束： 104 父进程id ： 10040 4 子进程id 开始： 11584 父进程id ： 10040 4 子进程id 结束： 11584 父进程id ： 10040 我是父进程
2.在循环启动后，列表中的进程依次join，会发生开始和执行，结束不一定有序，但必定在被join进程（父进程）的代码（print("我是父进程")之前。
import os import time import random from multiprocessing import Process def f(x): print(x,'子进程id 开始：',os.getpid(),'父进程id ：',os.getppid()) time.sleep(random.random()*5) print(x, '子进程id 结束：', os.getpid(), '父进程id ：', os.getppid()) return x if __name__ == '__main__': print('主进程id ：', os.getpid()) p_lst = [] for i in range(5): p = Process(target=f, args=(i,)) p.start() p_lst.append(p) [p.join() for p in p_lst] print("我是父进程")
主进程id ： 15804 0 子进程id 开始： 6556 父进程id ： 15804 2 子进程id 开始： 19300 父进程id ： 15804 1 子进程id 开始： 10176 父进程id ： 15804 3 子进程id 开始： 17164 父进程id ： 15804 4 子进程id 开始： 1944 父进程id ： 15804 0 子进程id 结束： 6556 父进程id ： 15804 1 子进程id 结束： 10176 父进程id ： 15804 4 子进程id 结束： 1944 父进程id ： 15804 3 子进程id 结束： 17164 父进程id ： 15804 2 子进程id 结束： 19300 父进程id ： 15804 我是父进程
3.自定义类继承Process类的形式开启进程的方式
# encoding=utf8
import os from multiprocessing import Process class MyProcess(Process): def __init__(self,name): super().__init__() self.name=name #需要重写run方法 def run(self): print('%s 子进程正在执行' %self.name,"进程id"+str(os.getpid())) if __name__ == '__main__': p1=MyProcess('1') p2=MyProcess('2') p3=MyProcess('3') p1.start() #start会自动调用run p2.start() # p2.run() p3.start() p1.join() p2.join() p3.join() print('主线程')
2 子进程正在执行 进程id2516 3 子进程正在执行 进程id10100 1 子进程正在执行 进程id3308 主线程
进程之间的数据隔离：
from multiprocessing import Process def work(): global n n=0 print('子进程内: ',n) if __name__ == '__main__': n = 100 p=Process(target=work) p.start() print('主进程内: ',n)
主进程内: 100
子进程内: 0
Daemon 守护进程
会随着主进程的结束而结束。
主进程创建守护进程
其一：守护进程会在主进程代码执行结束后就终止。
其二：守护进程内无法再开启子进程,否则抛出异常：AssertionError: daemonic processes are not allowed to have children
1.进程之间是互相独立的，主进程代码运行结束，守护进程随即终止
import os import time from multiprocessing import Process class Myprocess(Process): def __init__(self,person): super().__init__() self.person = person def run(self): time.sleep(1) print('%s 子进程正在执行' %self.name,"进程id"+str(os.getpid())) if __name__ == '__main__': p=Myprocess('1') #一定要在p.start()前设置,设置p为守护进程,禁止p创建子进程,并且父进程代码执行结束,p即终止运行 p.daemon=True p.start() time.sleep(10) # 在sleep时查看进程id对应的进程ps -ef|grep id
Myprocess-1 子进程正在执行 进程id2856
如果是随着主进程代码的结束而结束。就会打印不出来。
2.主进程结束守护进程也会立即结束，不会等待。
import time from multiprocessing import Process def f1(): while(True): time.sleep(0.1) print ("end123") if __name__ == '__main__': p1=Process(target=f1) p1.daemon=True p1.start() time.sleep(1) print("主进程结束")
#打印该行则主进程代码结束,则守护进程p1应该被终止.
end123
end123
end123
end123
end123
main-------
进程对象的其他方法：
进程对象的其他方法:terminate,is_alive
from multiprocessing import Process import time import random class Myprocess(Process): def __init__(self,person): self.name=person super().__init__() def run(self): print('%s正在和刘亦菲聊天' %self.name) time.sleep(random.randrange(1,5)) print('%s还在和刘亦菲聊天' %self.name) if __name__ == '__main__': p1=Myprocess('斌哥') p1.start() p1.terminate()#关闭进程,不会立即关闭,所以is_alive立刻查看的结果可能还是存活 print(p1.is_alive()) #结果为True time.sleep(1) print(p1.is_alive()) #结果为False
属性探查 name属性
import random import time from multiprocessing import Process class Myprocess(Process): def __init__(self,person): self.name=person # name属性是Process中的属性，标示进程的名字 super().__init__() # 执行父类的初始化方法会覆盖name属性 # self.name = person # 在这里设置就可以修改进程名字了 # self.person = person #如果不想覆盖进程名，就修改属性名称就可以了 def run(self): print('%s正在和刘亦菲聊天' %self.name) # print('%s正在聊天' %self.person) time.sleep(random.randrange(1,5)) print('%s正在和刘亦菲聊天' %self.name) # print('%s还在聊天' %self.person) if __name__ == '__main__': p1=Myprocess('斌哥') p1.start() print(p1.pid) #可以查看子进程的进程id
自定义进程有默认name,也可以自己设置。
进程同步
multiprocess.Lock 锁
multiprocess.Semaphore 信号量
multiprocess.Event 事件
锁
让多个任务可以同时在几个进程中并发处理，他们之间的运行没有顺序，一旦开启也不受我们控制。尽管并发编程让我们能更加充分的利用IO资源，但是也给我们带来了新的问题。
当多个进程使用同一份数据资源的时候，就会引发数据安全或顺序混乱问题。加锁的形式实现了顺序的执行，但是程序又重新变成串行了，这样确实会浪费了时间，却保证了数据的安全。
没有加锁的情况下
#文件db的内容为：{"count":5} #注意一定要用双引号，不然json无法识别 #并发运行，效率高，但竞争写同一文件，数据写入错乱 from multiprocessing import Process,Lock import time,json,random def search(): dic=json.load(open('db')) print('\033[43m剩余票数%s\033[0m' %dic['count']) def get(): dic=json.load(open('db')) time.sleep(0.1) #模拟读数据的网络延迟 if dic['count'] >0: dic['count']-=1 time.sleep(0.2) #模拟写数据的网络延迟 json.dump(dic,open('db','w')) print('\033[43m购票成功\033[0m') def task(): search() get() if __name__ == '__main__': for i in range(10): #模拟并发100个客户端抢票 p=Process(target=task) p.start()
加锁的情况下
#文件db的内容为：{"count":5} #注意一定要用双引号，不然json无法识别 #并发运行，效率高，但竞争写同一文件，数据写入错乱 from multiprocessing import Process,Lock import time,json,random def search(): dic=json.load(open('db')) print('\033[43m剩余票数%s\033[0m' %dic['count']) def get(): dic=json.load(open('db')) time.sleep(random.random()) #模拟读数据的网络延迟 if dic['count'] >0: dic['count']-=1 time.sleep(random.random()) #模拟写数据的网络延迟 json.dump(dic,open('db','w')) print('\033[32m购票成功\033[0m') else: print('\033[31m购票失败\033[0m') def task(lock): search() lock.acquire() get() lock.release() if __name__ == '__main__': lock = Lock() for i in range(10): #模拟并发100个客户端抢票 p=Process(target=task,args=(lock,)) p.start()
#加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改，即串行的修改，没错，速度是慢了，但牺牲了速度却保证了数据安全。 虽然可以用文件共享数据实现进程间通信，但问题是： 1.效率低（共享数据基于文件，而文件是硬盘上的数据） 2.需要自己加锁处理 #因此我们最好找寻一种解决方案能够兼顾： 1、效率高（多个进程共享一块内存的数据） 2、帮我们处理好锁问题。 这就是mutiprocessing模块为我们提供的基于消息的IPC通信机制： 队列和管道。 队列和管道都是将数据存放于内存中 队列又是基于（管道+锁）实现的，可以让我们从复杂的锁问题中解脱出来， 我们应该尽量避免使用共享数据，尽可能使用消息传递和队列，避免处理复杂的同步和锁问题，而且在进程数目增多时，往往可以获得更好的可获展性。
信号量 —— multiprocess.Semaphore
from multiprocessing import Process,Semaphore import time,random def incar(sem,user): sem.acquire() print('%s 进到四人小车' %user) time.sleep(random.randint(0,3)) #模拟每个人在车里中待的时间不同 sem.release() if __name__ == '__main__': sem=Semaphore(4) p_l=[] for i in range(13): p=Process(target=incar,args=(sem,'user%d' %(i+1),)) p.start() p_l.append(p) for i in p_l: i.join() # print('============》')
事件 —— multiprocess.Event
python线程的事件用于主线程控制其他线程的执行，事件主要提供了三个方法 set、wait、clear。
事件处理的机制：全局定义了一个“Flag”，如果“Flag”值为 False，那么当程序执行 event.wait 方法时就会阻塞，如果“Flag”值为True，那么event.wait 方法时便不再阻塞。
is_set() 查看event的状态
clear：将“Flag”设置为False
set：将“Flag”设置为True
from multiprocessing import Process, Event import time, random def car(e, n): while True: if not e.is_set(): # 进程刚开启，is_set()的值是Flase，模拟信号灯为红色 print('\033[31m红灯亮\033[0m，car%s等着' % n) e.wait() # 阻塞，等待is_set()的值变成True，模拟信号灯为绿色 print('\033[32m车%s 看见绿灯亮了\033[0m' % n) time.sleep(random.randint(3, 6)) if not e.is_set(): #如果is_set()的值是Flase，也就是红灯，仍然回到while语句开始 continue print('车开远了,car', n) break def police_car(e, n): while True: if not e.is_set():# 进程刚开启，is_set()的值是Flase，模拟信号灯为红色 print('\033[31m红灯亮\033[0m，car%s等着' % n) e.wait(0.1) # 阻塞，等待设置等待时间，等待0.1s之后没有等到绿灯就闯红灯走了 if not e.is_set(): print('\033[33m红灯,警车先走\033[0m，car %s' % n) else: print('\033[33;46m绿灯，警车走\033[0m，car %s' % n) break def traffic_lights(e, inverval): while True: time.sleep(inverval) if e.is_set(): print('######', e.is_set()) e.clear() # ---->将is_set()的值设置为False else: e.set() # ---->将is_set()的值设置为True print('***********',e.is_set()) if __name__ == '__main__': e = Event() for i in range(10): p=Process(target=car,args=(e,i,)) # 创建是个进程控制10辆车 p.start() for i in range(5): p = Process(target=police_car, args=(e, i,)) # 创建5个进程控制5辆警车 p.start() t = Process(target=traffic_lights, args=(e, 10)) # 创建一个进程控制红绿灯 t.start() print('============》')
扫一扫
2731
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
