生产者消费者模型
主要是为解耦
借助队列来实现生产者消费者模型
栈：先进后出（First In Last Out 简称 FILO）
队列： 先进先出（First In First Out 简称 FIFO）
import queue # 不能进行多进程之间的数据传输
（1）from multiprocessing import Queue 借助Queue解决生产者消费者模型
队列是安全的。
q = Queue(num)
num ： 队列的最大长度
q.get()# 阻塞等待获取数据，如果有数据直接获取，如果没有数据，阻塞等待
q.put()# 阻塞，如果可以继续往队列中放数据，就直接放，不能放就阻塞等待
q.get_nowait()# 不阻塞，如果有数据直接获取，没有数据就报错
q.put_nowait()# 不阻塞，如果可以继续往队列中放数据，就直接放，不能放就报错
（2）from multiprocessing import JoinableQueue#可连接的队列
JoinableQueue是继承Queue，所以可以使用Queue中的方法
并且JoinableQueue又多了两个方法
q.join()# 用于生产者。等待 q.task_done的返回结果，通过返回结果，生产者就能获得消费者当前消费了多少个数据
q.task_done() # 用于消费者，是指每消费队列中一个数据，就给join返回一个标识。
2 管道(了解)
from multiprocessing import Pipe
con1,con2 = Pipe()
管道是不安全的。
管道是用于多进程之间通信的一种方式。
如果在单进程中使用管道，那么就是con1收数据，就是con2发数据。
如果是con1发数据，就是con2收数据
如果在多进程中使用管道，那么就必须是父进程使用con1收，子进程就必须使用con2发
父进程使用con1发，子进程就必须使用con2收
父进程使用con2收，子进程就必须使用con1发
父进程使用con2发，子进程就必须使用con1收
在管道中有一个著名的错误叫做EOFError。是指，父进程中如果关闭了发送端，子进程还继 续接收数据，那么就会引发EOFError。
3 进程之间的共享内存
from multiprocessing import Manager,Value
m = Manager()
num = m.dict({键 : 值})
num = m.list([1,2,3])
4 进程池
进程池：一个池子，里边有固定数量的进程。这些进程一直处于待命状态，一旦有任务来，马上就有进程去处理。
因为在实际业务中，任务量是有多有少的，如果任务量特别的多，不可能要开对应那么多的进程数
开启那么多进程首先就需要消耗大量的时间让操作系统来为你管理它。其次还需要消耗大量时间让
cpu帮你调度它。
进程池还会帮程序员去管理池中的进程。
from multiprocessing import Pool
p = Pool(os.cpu_count() + 1)
进程池有三个方法：
map(func,iterable)
func：进程池中的进程执行的任务函数
iterable: 可迭代对象，是把可迭代对象中的每个元素依次传给任务函数当参数
apply(func,args=())： 同步的效率，也就是说池中的进程一个一个的去执行任务
func：进程池中的进程执行的任务函数
args: 可迭代对象型的参数，是传给任务函数的参数
同步处理任务时，不需要close和join
同步处理任务时，进程池中的所有进程是普通进程（主进程需要等待其执行结束）
apply_async(func,args=(),callback=None)： 异步的效率，也就是说池中的进程一次性都去执行任务
func：进程池中的进程执行的任务函数
args: 可迭代对象型的参数，是传给任务函数的参数
callback: 回调函数，就是说每当进程池中有进程处理完任务了，返回的结果可以交给回调函数，由回调函数进行进一步的处理,回调函数只有异步才有，同步是没有的
异步处理任务时，进程池中的所有进程是守护进程（主进程代码执行完毕守护进程就结束） 异步处理任务时，必须要加上close和join
回调函数的使用：
进程的任务函数的返回值，被当成回调函数的形参接收到，以此进行进一步的处理操作 回调函数是由主进程调用的，而不是子进程，子进程只负责把结果传递给回调函数
from multiprocessing import Process,Manager def func(num): num[0] -= 1 print('子进程中的num的值是',num) if __name__ == '__main__': m = Manager() num = m.list([1,2,3]) p = Process(target=func,args=(num,)) p.start() p.join() print('父进程中的num的值是',num)
from multiprocessing import Process,JoinableQueue q = JoinableQueue() # q.join()# 用于生产者。等待 q.task_done的返回结果，通过返回结果，生产者就能获得消费者当前消费了多少个数据 # q.task_done() # 用于消费者，是指每消费队列中一个数据，就给join返回一个标识。 # 假设生产者生产了100个数据，join就能记录下100这个数字。每次消费者消费一个数据，就必须要task_done返回一个标识，当生产者（join）接收到100个消费者返回来的标识的时候，生产者就能知道消费者已经把所有数据都消费完了。 from multiprocessing import Queue,Process import time def consumer(q,name,color): while 1: info = q.get() print('%s %s 拿走了%s \033[0m'%(color,name,info)) q.task_done() # 消费者如何判断，生产者是没来得及生产数据，还是生产者不再生产数据了？ # 如果你尝试用get_nowait() + try 的方式去尝试获得生产者不再生产数据，此时是有问题的。 def producer(q,product): for i in range(20): info = product + '的娃娃%s号'%str(i) q.put(info) q.join()# 记录了生产了20个数据在队列中,此时会阻塞等待消费者消费完队列中所有数据 if __name__ == '__main__': q = JoinableQueue(10) p_pro1 = Process(target=producer,args=(q,'岛国米饭保你爱')) p_con1 = Process(target=consumer,args=(q,'alex','\033[31m')) p_con1.daemon = True# 把消费者进程设为守护进程 p_con1.start() p_pro1.start() p_pro1.join()# 主进程等待生产者进程结束 # 程序有3个进程，主进程和生产者进程和消费者进程。 当主进程执行到35行代码时，主进程会等待生产进程结束 # 而生产进程中（第26行）会等待消费者进程把所有数据消费完，生产者进程才结束。 # 现在的状态就是 主进程等待生产者进程结束，生产者进程等待消费者消费完所有数据 # 所以，把消费者设置为守护进程。 当主进程执行完，就代表生产进程已经结束，也就代表消费者进程已经把队列中数据消费完 # 此时，主进程一旦结束，守护进程也就是消费者进程也就跟着结束。 整个程序也就能正常结束了。
from multiprocessing import Queue q = Queue(3) q.put(1) q.put('abc') q.put([4,5,6]) # print(123) # q.put('汉子') # try: # q.put_nowait('汉子') # except: # print('队列满了') # print(456) print(q.get()) print(q.get()) print(q.get()) # print(q.get())# 阻塞等待 try: print(q.get_nowait()) except: print('队列空了')
# from multiprocessing import Queue,Process # import time # # def consumer(q,name): # while 1: # info = q.get() # if info: # print('%s 拿走了%s'%(name,info)) # else:# 当消费者获得队列中数据时，如果获得的是None，就是获得到了生产者不再生产数据的标识 # break# 此时消费者结束即可 # # # 消费者如何判断，生产者是没来得及生产数据，还是生产者不再生产数据了？ # # 如果你尝试用get_nowait() + try 的方式去尝试获得生产者不再生产数据，此时是有问题的。 # # def producer(q,product): # for i in range(20): # info = product + '的娃娃%s号'%str(i) # q.put(info) # q.put(None)# 让生产者生产完数据后，给消费者一个不再生产数据的标识 # # if __name__ == '__main__': # q = Queue(10) # p_pro = Process(target=producer,args=(q,'岛国米饭保你爱')) # p_con = Process(target=consumer,args=(q,'alex')) # p_pro.start() # p_con.start() ################################################ 将生产者生产结束的标识，放到父进程中 from multiprocessing import Queue,Process import time def consumer(q,name,color): while 1: info = q.get() if info: print('%s %s 拿走了%s \033[0m'%(color,name,info)) else:# 当消费者获得队列中数据时，如果获得的是None，就是获得到了生产者不再生产数据的标识 break# 此时消费者结束即可 # 消费者如何判断，生产者是没来得及生产数据，还是生产者不再生产数据了？ # 如果你尝试用get_nowait() + try 的方式去尝试获得生产者不再生产数据，此时是有问题的。 def producer(q,product): for i in range(20): info = product + '的娃娃%s号'%str(i) q.put(info) if __name__ == '__main__': q = Queue(10) p_pro1 = Process(target=producer,args=(q,'岛国米饭保你爱')) p_pro2 = Process(target=producer,args=(q,'苍老师版')) p_pro3 = Process(target=producer,args=(q,'波多多版')) p_con1 = Process(target=consumer,args=(q,'alex','\033[31m')) p_con2 = Process(target=consumer,args=(q,'wusir','\033[32m')) p_l = [p_con1,p_con2,p_pro1,p_pro2,p_pro3] [i.start() for i in p_l] # 父进程如何感知到生产者子进程不再生产数据了？ p_pro1.join() p_pro2.join() p_pro3.join() q.put(None)# 几个消费者就要接受几个结束标识 q.put(None)
from multiprocessing import Pipe # con1,con2 = Pipe() # # con1.send('abc') # print(con2.recv()) # con2.send(123) # print(con1.recv())
from multiprocessing import Pipe,Process def func(con): con1,con2 = con con1.close()# 子进程使用con2和父进程通信，所以 while 1: try: print(con2.recv())#当主进程的con1发数据时，子进程要死循环的去接收。 except EOFError:# 如果主进程的con1发完数据并关闭con1，子进程的con2继续接收时，就会报错，使用try的方式，获取错误 con2.close()# 获取到错误，就是指子进程已经把管道中所有数据都接收完了，所以用这种方式去关闭管道 break if __name__ == '__main__': con1,con2 = Pipe() p = Process(target=func,args=((con1,con2),)) p.start() con2.close()# 在父进程中，使用con1去和子进程通信，所以不需要con2，就提前关闭 for i in range(10):# 生产数据 con1.send(i)# 给子进程的con2发送数据 con1.close()# 生产完数据，关闭父进程这一端的管道
from multiprocessing import Pool def func(num): num += 1 print(num) return num if __name__ == '__main__': p = Pool(5) res = p.map(func,[i for i in range(100)]) p.close() p.join() print('主进程中map的返回值',res)
from multiprocessing import Pool import requests import time,os def func(url): res = requests.get(url) print('子进程的pid:%s,父进程的pid：%s'%(os.getpid(),os.getppid())) # print(res.text) if res.status_code == 200: return url,res.text def cal_back(sta): url,text = sta print('回调函数的pid', os.getpid()) with open('a.txt','a',encoding='utf-8') as f: f.write(url + text) # print('回调函数中！',url) if __name__ == '__main__': p = Pool(5) l = ['https://www.baidu.com', 'http://www.jd.com', 'http://www.taobao.com', 'http://www.mi.com', 'http://www.cnblogs.com', 'https://www.bilibili.com', ] print('主进程的pid',os.getpid()) for i in l: p.apply_async(func, args=(i,),callback=cal_back)# # 异步执行任务func，每有一个进程执行完任务后，在func中return一个结果，结果会自动的被callback指定的函数，当成形式参数来接收到 p.close() p.join()
from multiprocessing import Pool import time def func(num): num += 1 return num if __name__ == '__main__': p = Pool(5) start = time.time() l = [] for i in range(10000): res = p.apply_async(func,args=(i,))# 异步处理这100个任务，异步是指，进程中有5个进程，一下就处理5个任务，接下来哪个进程处理完任务了，就马上去接收下一个任务 l.append(res) p.close() p.join() print(time.time() - start) # [print(i.get()) for i in l]
from multiprocessing import Pool import time def func(num): num += 1 return num if __name__ == '__main__': p = Pool(5) start = time.time() for i in range(10000): res = p.apply(func,args=(i,))# 同步处理这100个任务，同步是指，哪怕我进程中有5个进程，也依旧是1个进程1个进程的去执行任务 # time.sleep(0.5) print(res) print(time.time() - start)
from multiprocessing import Pool import requests import time def func(num): time.sleep(0.5) print(num+1) if __name__ == '__main__': p = Pool(5) for i in range(100): p.apply_async(func, args=(i,)) # time.sleep(0.5) p.close() p.join()
from multiprocessing import Pool import requests import time def func(url): res = requests.get(url) print(res.text) if res.status_code == 200: return 'ok' if __name__ == '__main__': p = Pool(5) l = ['https://www.baidu.com', 'http://www.jd.com', 'http://www.taobao.com', 'http://www.mi.com', 'http://www.cnblogs.com', 'https://www.bilibili.com', ] start = time.time() for i in l: p.apply(func,args=(i,)) apply_= time.time() - start start = time.time() for i in l: p.apply_async(func, args=(i,)) p.close() p.join() print('同步的时间是%s，异步的时间是%s'%(apply_, time.time() - start))
import os from multiprocessing import Pool,Process import time def func(num): num += 1 print(num) if __name__ == '__main__': p = Pool(os.cpu_count() + 1) start = time.time() p.map(func,[i for i in range(100)]) p.close()# 指不允许在向进程池中添加任务 p.join()# 等待进程池中所有进程执行完所有任务 print('进程池做任务的效率：',time.time() - start) start = time.time() p_l = [] for i in range(100): p1 = Process(target=func,args=(i,)) p1.start() p_l.append(p1) [p1.join() for p1 in p_l] print('多进程直接做任务的效率',time.time() - start) # p.apply()是指让进程池中的进程，同步的帮你做任务 # p.apply_async()# 是指让进程池中的进程，异步的帮你做任务
浙公网安备 33010602011771号