Day34 python基础--并发编程基础3
一，进程之间通信，简称：IPC:inter-process-communication
概念：
1.多个进程之间有一些固定的通信内容（一些信号）
2.实现方式：socket基于文件家族通信
3.进程之间虽然内存不共享，但是可以通信的
Lock,Semaphore,Event 都会进行进程之间的通信，只不过这些通信的内容我们不能改变
进程队列：先进先出 ****
import queue from multiprocessing import Queue q = Queue() #若不设置，则对列长度不限制 q = Queue(2) #设置队列长度，队列满了会阻塞 #put()与put_nowait() q.put() #若队列已满，数据进不去，并阻塞 q.put_nowait(3) #若队列已满，进不去队列，则报错，并丢弃本次数据 #get()与get_nowait() q.get() #若队列为空，或取值不存在，则阻塞 q.get_nowait(3) #如果get队列，队列为空，或取值不存在，则报错 #empty()与full() 慎用，在多进程对一个队列操作时，不准！ q.empty()：查看队列是否为空 q.full():查看队列是否为满 #nowait用法 try: print(q.get_nowait()) except queue.Empty: print('empty')
#例：主进程与子进程通过进程队列传递数据 from mulitprocessing import Process,Queue def consume(q): print(q.get()) #取值 q.put('abc') #存值 if __name__ == '__main__': q = Queue() p = Process(target=consume,args=(q,)) p.start() q.put({'123':123}) #存值 p.join() #等待子进程执行完成 print(q.get()) #取值
进程队列应用：生产者消费者模型
#做饭吃饭的例子 import time import random from multiprocessing import Queue,Process def consumer(q,name): #处理数据/消费者 while True: food = q.get() if food is None:break print('%s吃了一个%s'%(name,food)) time.sleep(random.uniform(0.5,1)) def producer(q,name,food): #获取数据/生成者 for i in range(10): time.sleep(random.uniform(0.3,0.8)) print('%s生产了%s%s'%(name,food,i)) q.put(food+str(i)) if __name__ == '__main__': q = Queue() c1 = Process(target=consumer,args=(q,'alex')) c2 = Process(target=consumer,args=(q,'wusir')) # c1.daemon = True c1.start() c2.start() p1 = Process(target=producer,args=(q,'taibai','饭')) p2 = Process(target=producer,args=(q,'egon','菜')) p1.start() p2.start() p1.join() p2.join() q.put(None) #有几个consumer就需要在最后放几个none q.put(None)
进程队列之joinablequeue模块：
joinablequeue是一个类，包含put()，get()，task_done()，join()方法
import time import random from multiprocessing import Queue,Process from multiprocessing import JoinableQueue def consumer(q,name): #处理数据 while True: food = q.get() print('%s吃了一个%s'%(name,food)) time.sleep(random.uniform(0.5,1)) q.task_done() #向q.join()发送一次信号,证明一个数据已经被取走了 def producer(q,name,food): #获取数据 for i in range(10): time.sleep(random.uniform(0.3,0.8)) print('%s生成%s%s'%(name,food,i)) q.put(food+str(i)) #生产数据并存值到进程队列 if __name__ == '__main__': q = JoinableQueue() c1 = Process(target=consumer,args=(q,'alex')) c1.daemon = True #消费者进程设置为守护进程 c2 = Process(target=consumer,args=(q,'wusir')) c2.daemon = True #消费者进程设置为守护进程 c1.start() c2.start() p1 = Process(target=producer,args=(q,'taibai','饭')) p2 = Process(target=producer,args=(q,'egon','菜')) p1.start() p2.start() p1.join() #生产者进程执行完成前阻塞 p2.join() #生产者进程执行完成前阻塞 q.join() #生产完毕后，使用此方法进行阻塞，直到队列中所有项目均被处理（即:ask_done的值为0） #当队列中的数据被处理完后，结束阻塞，消费者程序随着主进程代码完成而结束
二，管道 **
1.队列是基于管道实现
2.管道是基于socket、pickle实现的
3.管道与队列的区别
队列：进程之间数据安全，严格控制数据进出（管道+锁实现简便的IPC机制）
管道：进程之间数据是不安全的，且存取数据复制
4.pipe的端口管理：
pipe的端口管理不会随着某一个进程的关闭而关闭，pipe的端口属于系统资源，需要手动释放
操作系统来管理进程对这个端口的使用
操作系统管理pipe端口，每当手动关闭一个端口计算-1，直到所有可以传值的端口关闭，剩余一个端口的时候，系统报错，我们可以利用异常处理对报错信息进行处理并关闭子进程。
from multiprocessing import Pipe left,right = Pipe() left.send(12345) #管道中的存值与取值，send,recv通过pickel和socket实现 print(right.recv())
from multiprocessing import Pipe,Process def consumer(left,right): left.close() #关闭子进程right端口 while True: try: print(right.recv()) #当子进程取不到值时，并可以Pipe可以接受传值的端口都被关闭时，则报错 except EOFError: #利用报错，进行异常处理，以结束子进程 break if __name__ == '__main__': left, right = Pipe() Process(target=consumer, args=(left, right)).start() right.close() #关闭主进程right端口 for i in range(10): left.send('饭菜%s'%i) left.close() #当数据存取完成是，关闭left端口，否则子程序的pipe端口管理会认为，数据还没有存取完毕，子进程会进入阻塞状态
三，进程池 *****
1:为什么要有进程池？
开启过多的进程并不能提高你的效率，反而会降低效率
2.进程任务的概念：
计算密集型：充分占用cpu，多进程可以充分利用多核
适合开启多进程，但是不适合开启很多多进程
IO密集型：大部分时间都在阻塞队列，而不是在运行状态中
根本不适合开启多进程
3.进程池的创建
#实例化 传参数（进程的个数） 进程个数默认为cpu个数 或 为1，一般为os.cpu_count() + 1 p = Pool() #提交任务 #同步提交func到一个子进程中执行 ret = p.apply(func,args=(i,)) #返回值：子进程对应函数的返回值 #一个一个顺序执行，并没有任何并发效果 #异步提交func到一个子进程中执行 ret = p.apply(apply_async,args=(i,)) #没有返回值，要想所有任务能够顺利的执行完毕 p.close() #关闭进程池，用户不能再向这个池中提交任务了 p.join() #必须先close再join，阻塞直到进程池中所有任务执行完毕 #有返回值的情况下 ret.get()#get不能在提交任何之后立刻执行，应该先提交所有任务，再通过get得到返回值 #map()方法 #异步提交的简化版本 #自带close和join方法
#例：进程池与多进程的效率对比 import time from multiprocessing import Pool,Process def func(num): print('做了第%s件衣服'%num) if __name__ == '__main__': #以进程池的形式执行500个任务 strat = time.time() p = Pool(4) for i in range(500): p.apply_async(func,args=(i,)) p.close() p.join() print(time.time() - strat) #以多进程的形式执行100个任务 strat = time.time() p_lst = [] for i in range(100): p = Process(target=func,args=(i,)) p.start() p_lst.append(p) for p in p_lst: p.join() print(time.time() - strat)
#以完全同步的方式提交任务（apply） import os import time from multiprocessing import Pool def task(num): time.sleep(1) print('%s:%s'%(num,os.getpid())) return num**2 #进程池有IPC机制，可以直接return if __name__ == '__main__': p = Pool(4) for i in range(20): ret = p.apply(task,args=(i,)) #提交任务的方法，同步提交（自带join阻塞） print(ret) #任务逐个提交并完成后再返回
#以完全异步的方式提交任务（apply_async） import os import time from multiprocessing import Pool def task(num): time.sleep(1) print('%s:%s'%(num,os.getpid())) return num**2 if __name__ == '__main__': p = Pool(4) #默认值为os.cpu_count() or 1 ，一般为os.cpu_count()+1 res_lst = [] for i in range(20): ret = p.apply_async(task,args=(i,)) res_lst.append(ret) for res in res_lst: #异步方式取返回值 print(res.get())
