多进程,代码示例
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 表示调用对象的位置参数元组,args=(1,2,'egon',) kwargs 表示调用对象的字典,kwargs={'name':'egon','age':18} name 为子进程的名称
方法介绍:
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 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字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性,这类连接只有在具有相同的身份验证键时才能成功(了解即可)
Process类的使用
注意:在Windows中,Process()必须放在 if __name__ == "__main__": 下执行
一个python文件通常有两种使用方法:一个是作为脚本执行,一个是import到其他文件中被调用执行。 因此 if __name__ == 'main': 的作用就是控制这两种情况执行代码的过程,在 if __name__ == 'main': 下的代码只有在第一种情况下(即文件作为脚本直接执行)才会被执行,而 import 到其他脚本中是不会被执行的。 每个python模块/文件都包含内置变量__name__。当该模块作为脚本执行时,__name__==文件名.py;当该模块import到其他模块中时,__name__==文件名。而__main__始终等于文件名.py。 所以,当文件当做脚本执行时,if为真,才会执行
创建并开启子进程的两种方法:
from multiprocessing import Process def func(name): print("my name is %s"%name) p = Process(target=func,args=("张三",)) # 必须加逗号,因为要传 元组 p.start() from multiprocessing import Process class Cls(Process): def __init__(self,name): super().__init__() self.name = name def run(self): print("my name is %s"%name) p = Cls("张三") p.start()
进程之间的内存空间是隔离的
from multiprocessing import Process n=100 def work(): global n n=0 print('子进程内: ',n) if __name__ == '__main__': p=Process(target=work) p.start() print('主进程内: ',n) # 主进程与子进程n的值不同,说明 进程间的内存空间是隔离的
Process对象的join方法
from multiprocessing import Process def func(name): print("my name is %s"%name) p1 = Process(target=func,args=("张三",)) p2 = Process(target=func,args=("李四",)) p1.start() p2.start() p1.join() p2.join() print("主进程") 程序中添加了join,变成串行了吗? 不是,join只是让主进程等待子进程结束,卡住的是主进程而不是子进程。主进程等待的时候,各个子进程仍在执行。执行花费的总时间是 子进程中耗时最长的那个。
Process对象的其他方法或属性(了解),name,pid,is_alive,terminate
from multiprocessing import Process import time def func(name): print("my name is %s"%name) time.sleep(3) print("my name is %s"%name) p = Process(target=func,args=("张三",),name="进程名字") p.start()
print(p.name) # 进程名字 print(p.pid) # 进程pid
print(p.is_alive()) # 判断进程是否在运行,True p.terminate() # 关闭进程,但不会立即关闭 time.sleep(1) print(p.is_alive()) # False
思考
from multiprocessing import Process def func(name): print("my name is %s"%name) p = Process(target=func,args=("张三",)) p.start() p.join() # 等待进程p结束后,join函数内部会发送系统调用wait,去告诉操作系统回收进程的pid print(p.pid) # 能否打印进程的pid 可以 p.join()是向操作系统发送请求,告知操作系统p的id号不需要再占用了,回收掉 此时,在父进程中还可以看到p.pid,但此时p.pid是一个无意义的id号,因为操作系统已经将编号回收
守护进程
主进程创建守护进程。
守护进程会在主进程执行结束后终止
守护进程内无法再开启子进程,否则会抛出异常:AssertionError: daemonic processes are not allowed to have children
注意:进程间是相互独立的,主进程代码运行结束,守护进程也随即终止
from multiprocessing import Process def func(name): print("my name is %s"%name) p = Process(target=func,args=("张三",)) p.daemon = True p.start() 守护进程,一定要在p.start()之前设置,禁止p再创建子进程
进程同步(锁)
进程间数据不共享,但是共享一套文件系统,所以访问同一个文件是没有问题的。但当修改文件时,就会出现错误,此时,可以加锁处理
#由并发变成了串行,牺牲了运行效率,但避免了竞争 from multiprocessing import Process,Lock import os,time def work(lock): lock.acquire() print('%s is running' %os.getpid()) time.sleep(2) print('%s is done' %os.getpid()) lock.release() if __name__ == '__main__': lock=Lock() for i in range(3): p=Process(target=work,args=(lock,)) p.start()
总结:
加锁可以保证多个进程修改同一数据时,同一时间只能有一个任务可以修改,即串行的修改,但是 牺牲了速度却保证了数据安全
因此,我们需要的解决问题方法,同时兼顾高效率(多个进程共享一块内存的数据),并且帮我们处理好锁的问题。
这就是mutiprocessing模块为我们提供的基于消息的IPC通信机制:队列和管道
1.队列和管道,都是将数据存放在内存中
2.队列是基于 管道+锁 实现的,可以让我们从负责的锁问题中解脱出来
我们应该尽量避免使用共享数据,尽可能使用消息传递和队列,避免处理复杂的同步和锁问题,而且在进程数目增多时,往往可以获得更好的可扩展性。
队列(推荐使用) Queue
进程彼此之间互相隔离,要实现进程间通信(IPC),multiprocessing模块支持两种形式:队列和管道,这两种方式都是使用消息传递的。
创建队列的类(底层就是以管道和锁定的方式实现):
Queue([maxsize]):创建共享的进程队列,Queue是多进程安全的队列,可以使用Queue实现多进程之间的数据传递,maxsize队列中允许最大项目,不设置则没有大小限制
方法介绍:
1 q.put方法用以插入数据到队列中,put方法还有两个可选参数:block和timeout。
如果block为True(默认值),并且timeout为正值,该方法会阻塞timeout所指定的时间,直到该队列有剩余的空间。如果超时,会抛出Queue.Full异常。如果block为False,但该Queue已满,会立即抛出Queue.Full异常。 2 q.get方法可以从队列中读取并删除一个元素。同样,get方法也有两个可选参数:blocked和timeout。
如果blocked为True(默认),并且timeout为正值,那么在等待时间内没有取到任何元素,会抛出Queue.Empty异常。如果blocked为False,有两种情况存在,如果Queue有一个值可用,则立即返回,否则,如果队列为空,则立即抛出Queue.Empty异常。 3 q.get_nowait() == q.get(False) 4 q.put_nowait() == q.put(False) 5 q.empty() 判断q是否为空,该方法不可靠,因为返回结果的过程中,可能会对q进行操作 6 q.full() 判断q是否已满,该方法不可靠,因为返回结果的过程中,可能会对q进行操作 7 q.cancel_join_thread() 不会在进程退出时自动连接后台线程,可以防止join_thread()方法阻塞。 8 q.close() 关闭队列。调用此方法,后台线程将继续写入那些已经入列但尚未写入的数据,但将在此方法执行完成时马上关闭。
如果q被垃圾收集,将调用此方法。关闭队列不会在队列使用者中产生任务类型的数据结束信号或异常。比如:如果某个使用者正阻塞在get()操作上,关闭生产者中的队列不会导致get()方法返回错误。 9 q.join_thread(): 连接队列的后台线程。此方法用于调用q.close()方法后,等待所有队列项被消耗。默认情况下,此方法由不是q的原始创建者的所有进程调用。调用q.cancel_join_thread方法可以禁止这种行为。
from multiprocessing import Process,Queue q = Queue(3) # q只能存放三个元素 q.put(1) q.put(2) q.put(3) print(q.full()) # q满了 print(q.get()) # 先进先出,按顺序取 print(q.get()) print(q.get()) print(q.empty()) # q空了
管道 Pipe
进程间通信(IPC)的另一种方式,推荐使用 队列Queue
创建管道的类:
Pipe([dumplex]),在进程之间创建一条管道,并返回元组(conn1,conn2),其中conn1,conn2表示管道两段的连接对象,但 必须在产生Process对象之前产生管道
参数介绍:
duplex:默认管道是全双工的,如果将duplex设成False,conn1只能用于接收,conn2只能用于发送。
主要方法:
conn1.recv():接收conn2.send(obj)发送的对象,如果没有消息可接收,recv方法会一直阻塞,如果连接的另外一端已经关闭,那么recv方法会抛出EOFError。
conn1.send(obj): 通过链接发送对象,obj是与序列化兼容的任意对象
其他方法:
conn1.close(): 关闭连接,如果conn1被垃圾回收,将自动调用此方法
conn1.fileno():返回连接使用的整数文件描述
conn1.poll([timeout]):如果连接上的数据可用,返回True,不设置timeout则立即返回结果,设置为None,将一直等待数据到达
conn1.recv_bytes([maxlength]):接收s.send_bytes()方法发送的一条完整的字节消息。maxlength指定要接收的最大字节数。如果进入的消息超过了这个最大值,将引发IOError异常,并且在连接上无法进行进一步读取,如果连接的另外一端已经关闭,再也不存在任何数据,将引发EOFError异常。
conn.send_bytes(buffer[,offset[,size]]):通过连接发送字节数据缓冲区,buffer是支持缓冲区接口的任意对象,offset是缓冲区中的字节偏移量,而size是要发送字节数。结果数据以单条消息的形式发出,然后调用c.recv_bytes()函数进行接收。
conn1.recv_bytes_into(buffer[,offset]):接收一条完整的字节消息,并把它保存在buffer对象中,该对象支持可写入的缓冲区接口(即bytearray对象或类似的对象)。offset指定缓冲区中放置消息处的字节位移,返回值是收到的字节数。如果消息长度大于可用的缓冲区空间,将引发BufferTooShort异常。
from multiprocessing import Process,Pipe import time,os def consumer(p,name): left,right=p left.close() while True: try: baozi=right.recv() print('%s 收到包子:%s' %(name,baozi)) except EOFError: right.close() break def producer(seq,p): left,right=p right.close() for i in seq: left.send(i) # time.sleep(1) else: left.close() if __name__ == '__main__': left,right=Pipe() c1=Process(target=consumer,args=((left,right),'c1')) c1.start() seq=(i for i in range(10)) producer(seq,(left,right)) right.close() left.close() c1.join() print('主进程')
注意:生产者和消费者都没有使用管道的某个端点,就应该将其关闭。如在生产者中关闭管道的右端,在消费者中关闭管道的左端。如果忘记执行这些步骤,程序可能再消费者中的recv()操作上挂起。管道是由操作系统进行引用计数的,必须在所有进程中关闭管道后才能生产EOFError异常。因此在生产者中关闭管道不会有任何效果,付费消费者中也关闭了相同的管道端点。
from multiprocessing import Process,Pipe import time,os def adder(p,name): server,client=p client.close() while True: try: x,y=server.recv() except EOFError: server.close() break res=x+y server.send(res) print('server done') if __name__ == '__main__': server,client=Pipe() c1=Process(target=adder,args=((server,client),'c1')) c1.start() server.close() client.send((10,20)) print(client.recv()) client.close() c1.join() print('主进程') #注意:send()和recv()方法使用pickle模块对对象进行序列化。
共享数据 Manager
进程间数据是独立的,可以借助于队列或管道实现通信,二者都是基于消息传递的。
虽然进程间数据独立,但可以通过Manager实现数据共享,事实上Manager的功能远不止于此。
from multiprocessing import Manager,Process,Lock import os def work(d,lock): # with lock: #不加锁而操作共享的数据,肯定会出现数据错乱 d['count']-=1 if __name__ == '__main__': lock=Lock() with Manager() as m: dic=m.dict({'count':100}) p_l=[] for i in range(100): p=Process(target=work,args=(dic,lock)) p_l.append(p) p.start() for p in p_l: p.join() print(dic) #{'count': 94}
信号量(了解) Semaphore
互斥锁同时只允许一个线程更改数据,而Semaphore是同时一定数量的线程更改数据,
信号量与进程池的概念很像,但是要区分开,信号量涉及到加锁的概念。
from multiprocessing import Process,Semaphore import time,random def go_wc(sem,user): sem.acquire() print('%s 占到一个茅坑' %user) time.sleep(random.randint(0,3)) #模拟每个人拉屎速度不一样,0代表有的人蹲下就起来了 sem.release() if __name__ == '__main__': sem=Semaphore(5) p_l=[] for i in range(13): p=Process(target=go_wc,args=(sem,'user%s' %i,)) p.start() p_l.append(p) for i in p_l: i.join() print('============》')
事件(了解) Event
python线程的事件用于主线程控制其他线程的执行,事件主要提供了三个方法:set,wait,clear
clear:将"Flag"设置为False,set:将"Flag"设置为True。
事件处理机制:全局定义了一个"Flag",如果Flag值为False,那么当程序执行event.wait方法时就会阻塞;如果Flag值为True,那么当程序执行event.wait方法时不会阻塞
#_*_coding:utf-8_*_ #!/usr/bin/env python from multiprocessing import Process,Event import time,random def car(e,n): while True: if not e.is_set(): #Flase print('\033[31m红灯亮\033[0m,car%s等着' %n) e.wait() print('\033[32m车%s 看见绿灯亮了\033[0m' %n) time.sleep(random.randint(3,6)) if not e.is_set(): continue print('走你,car', n) break def police_car(e,n): while True: if not e.is_set(): print('\033[31m红灯亮\033[0m,car%s等着' % n) e.wait(1) print('灯的是%s,警车走了,car %s' %(e.is_set(),n)) break def traffic_lights(e,inverval): while True: time.sleep(inverval) if e.is_set(): e.clear() #e.is_set() ---->False else: e.set() if __name__ == '__main__': e=Event() # for i in range(10): # p=Process(target=car,args=(e,i,)) # p.start() for i in range(5): p = Process(target=police_car, args=(e, i,)) p.start() t=Process(target=traffic_lights,args=(e,10)) t.start() print('============》')
进程池 Pool
在利用python进行系统管理的时候,特别是同时操作多个文件目录,或者远程控制多台主机,并且操作可以节约大量的时间。多进程是实现并发的手段之一,需要注意的是:
1.很明显需要并发执行的任务通常远大于核数
2.一个操作系统不可能无线开启进程,通常有几核就开启几个进程
3.进程开启过多,会占用系统资源,效率反而会下降,而且开启多余核数的进程也无法做到并行。
我们可以通过维护一个进程池来控制进程数目,规定最小进程数和最大进程数
对于远程过程调用的高级应用编程语言,应该使用进程池,Pool可以提供指定数量的进程,供用户调用,当有新的请求提交到pool中时,如果池还没有满,那么就会创建一个新的进程来执行该请求;如果池中的进程数已经达到规定最大值,那么该请求就会等待,直到池中有进程结束,就重用进程池中的进程。比如:指定进程池数量为3个,那么进程池会创建3个进程,始终由这三个进程去执行任务,不会开启其他进程。
创建进程池的类:
Pool([numprocess[,initializer[,initargs]]])
参数介绍:
1 numprocess:要创建的进程数,如果省略,将默认使用cpu_count()的值 2 initializer:是每个工作进程启动时要执行的可调用对象,默认为None 3 initargs:是要传给initializer的参数组
主要方法介绍:
1 p.apply(func [, args [, kwargs]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果。需要强调的是:此操作并不会在所有池工作进程中并执行func函数。如果要通过不同参数并发地执行func函数,必须从不同线程调用p.apply()函数或者使用p.apply_async() 2 p.apply_async(func [, args [, kwargs]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果。此方法的结果是AsyncResult类的实例,callback是可调用对象,接收输入参数。当func的结果变为可用时,将理解传递给callback。callback禁止执行任何阻塞操作,否则将接收其他异步操作中的结果。 3 4 p.close():关闭进程池,防止进一步操作。如果所有操作持续挂起,它们将在工作进程终止前完成 5 P.jion():等待所有工作进程退出。此方法只能在close()或teminate()之后调用
其他方法介绍:
方法apply_async()和map_async()的返回值是AsyncResul的实例obj。实例具有以下方法
obj.get():返回结果,如果有必要则等待结果到达。timeout是可选的。如果在指定时间内还没有到达,将引发一场。如果远程操作中引发了异常,它将在调用此方法时再次被引发。
obj.ready():如果调用完成,返回True
obj.successful():如果调用完成且没有引发异常,返回True,如果在结果就绪之前调用此方法,引发异常
obj.wait([timeout]):等待结果变为可用。
obj.terminate():立即终止所有工作进程,同时不执行任何清理或结束任何挂起工作。如果p被垃圾回收,将自动调用此函数
应用:
from multiprocessing import Pool import os,time def work(n): print('%s run' %os.getpid()) time.sleep(3) return n**2 if __name__ == '__main__': p=Pool(3) #进程池中从无到有创建三个进程,以后一直是这三个进程在执行任务 res_l=[] for i in range(10): res=p.apply(work,args=(i,)) #同步调用,直到本次任务执行完毕拿到res,等待任务work执行的过程中可能有阻塞也可能没有阻塞,但不管该任务是否存在阻塞,同步调用都会在原地等着,只是等的过程中若是任务发生了阻塞就会被夺走cpu的执行权限 res_l.append(res) print(res_l)
from multiprocessing import Pool import os,time def work(n): print('%s run' %os.getpid()) time.sleep(3) return n**2 if __name__ == '__main__': p=Pool(3) #进程池中从无到有创建三个进程,以后一直是这三个进程在执行任务 res_l=[] for i in range(10): res=p.apply_async(work,args=(i,)) #同步运行,阻塞、直到本次任务执行完毕拿到res res_l.append(res) #异步apply_async用法:如果使用异步提交的任务,主进程需要使用jion,等待进程池内任务都处理完,然后可以用get收集结果,否则,主进程结束,进程池可能还没来得及执行,也就跟着一起结束了 p.close() p.join() for res in res_l: print(res.get()) #使用get来获取apply_aync的结果,如果是apply,则没有get方法,因为apply是同步执行,立刻获取结果,也根本无需get
#一:使用进程池(异步调用,apply_async) #coding: utf-8 from multiprocessing import Process,Pool import time def func(msg): print( "msg:", msg) time.sleep(1) return msg if __name__ == "__main__": pool = Pool(processes = 3) res_l=[] for i in range(10): msg = "hello %d" %(i) res=pool.apply_async(func, (msg, )) #维持执行的进程总数为processes,当一个进程执行完毕后会添加新的进程进去 res_l.append(res) print("==============================>") #没有后面的join,或get,则程序整体结束,进程池中的任务还没来得及全部执行完也都跟着主进程一起结束了 pool.close() #关闭进程池,防止进一步操作。如果所有操作持续挂起,它们将在工作进程终止前完成 pool.join() #调用join之前,先调用close函数,否则会出错。执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束 print(res_l) #看到的是<multiprocessing.pool.ApplyResult object at 0x10357c4e0>对象组成的列表,而非最终的结果,但这一步是在join后执行的,证明结果已经计算完毕,剩下的事情就是调用每个对象下的get方法去获取结果 for i in res_l: print(i.get()) #使用get来获取apply_aync的结果,如果是apply,则没有get方法,因为apply是同步执行,立刻获取结果,也根本无需get #二:使用进程池(同步调用,apply) #coding: utf-8 from multiprocessing import Process,Pool import time def func(msg): print( "msg:", msg) time.sleep(0.1) return msg if __name__ == "__main__": pool = Pool(processes = 3) res_l=[] for i in range(10): msg = "hello %d" %(i) res=pool.apply(func, (msg, )) #维持执行的进程总数为processes,当一个进程执行完毕后会添加新的进程进去 res_l.append(res) #同步执行,即执行完一个拿到结果,再去执行另外一个 print("==============================>") pool.close() pool.join() #调用join之前,先调用close函数,否则会出错。执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束 print(res_l) #看到的就是最终的结果组成的列表 for i in res_l: #apply是同步的,所以直接得到结果,没有get()方法 print(i)
回调函数
需要回调函数的场景:进程池中任何一个任务一旦处理完了,就立即告知主进程:我好了额,你可以处理我的结果了。主进程则调用一个函数去处理该结果,该函数即回调函数
我们可以把耗时间(阻塞)的任务放到进程池中,然后指定回调函数(主进程负责执行),这样主进程在执行回调函数时就省去了I/O的过程,直接拿到的是任务的结果。
from multiprocessing import Pool import requests import json import os def get_page(url): print('<进程%s> get %s' %(os.getpid(),url)) respone=requests.get(url) if respone.status_code == 200: return {'url':url,'text':respone.text} def pasrse_page(res): print('<进程%s> parse %s' %(os.getpid(),res['url'])) parse_res='url:<%s> size:[%s]\n' %(res['url'],len(res['text'])) with open('db.txt','a') as f: f.write(parse_res) if __name__ == '__main__': urls=[ 'https://www.baidu.com', 'https://www.python.org', 'https://www.openstack.org', 'https://help.github.com/', 'http://www.sina.com.cn/' ] p=Pool(3) res_l=[] for url in urls: res=p.apply_async(get_page,args=(url,),callback=pasrse_page) res_l.append(res) p.close() p.join() print([res.get() for res in res_l]) #拿到的是get_page的结果,其实完全没必要拿该结果,该结果已经传给回调函数处理了 ''' 打印结果: <进程3388> get https://www.baidu.com <进程3389> get https://www.python.org <进程3390> get https://www.openstack.org <进程3388> get https://help.github.com/ <进程3387> parse https://www.baidu.com <进程3389> get http://www.sina.com.cn/ <进程3387> parse https://www.python.org <进程3387> parse https://help.github.com/ <进程3387> parse http://www.sina.com.cn/ <进程3387> parse https://www.openstack.org [{'url': 'https://www.baidu.com', 'text': '<!DOCTYPE html>\r\n...',...}] '''
如果在主进程中等待进程池中所有任务都执行完毕后,再统一处理结果,则无需回调函数
from multiprocessing import Pool import time,random,os def work(n): time.sleep(1) return n**2 if __name__ == '__main__': p=Pool() res_l=[] for i in range(10): res=p.apply_async(work,args=(i,)) res_l.append(res) p.close() p.join() #等待进程池中所有进程执行完毕 nums=[] for res in res_l: nums.append(res.get()) #拿到所有结果 print(nums) #主进程拿到所有的处理结果,可以在主进程中进行统一进行处理