#队列中的ipc(进程间通信),作用是为了降低耦合性
# from multiprocessing import Process,Queue
#
# def consumer(q,name):
# while 1:
# a=q.get()#获得队列数据
# if a:
# print("%s拿走了%s"%(name,a))
# else:
# print("没货了")
# break
#
# def producer(q,pro):
# for i in range(20):
# a="%s充气娃娃%s"%(pro,i)
# q.put(a)#往队列中放置数据
# # q.put(None)
#
# if __name__ == '__main__':
# q=Queue()#实例化一个队列
# p_pro=Process(target=producer,args=(q,"林志玲版"))
# p_pro1 = Process(target=producer, args=(q, "刘亦菲版"))
# p_pro2= Process(target=producer, args=(q, "波多版"))
# p_con1=Process(target=consumer,args=(q,"盖伦"))
# p_con2 = Process(target=consumer, args=(q, "压缩"))
# l=[p_con1,p_con2,p_pro,p_pro1,p_pro2,]
# [i.start() for i in l]
# p_pro.join()
# p_pro1.join()
# p_pro2.join()
# q.put(None)#传入标识,使消费者子进程停止
# q.put(None)
# JoinableQueue的应用:
# from multiprocessing import Process,JoinableQueue
#
# def consumer(q,name):
# while 1:
# a=q.get()
# print("%s获得%s"%(name,a))
# q.task_done()
# def producer(q):
# for i in range(20):
# a="%s充气娃娃"%str(i+1)
# q.put(a)
# q.join()
# if __name__ == '__main__':
# q=JoinableQueue(10)
# p_pro=Process(target=producer,args=(q,))
# p_con=Process(target=consumer,args=(q,"alex"))
# p_pro.start()
# p_con.daemon=True
# p_con.start()
# p_pro.join()
# 存取钱的模板:
# from multiprocessing import Manager,Process,Lock
#
# def put_in(num,l):
# l.acquire()
# for i in range(100):
# num['money']=num['money']+1
# print(num['money'])
# l.release()
#
# def put_out(num,l):
# l.acquire()
# for i in range(100):
# num['money']=num['money']-1
# print(num['money'])
# l.release()
#
# if __name__ == '__main__':
# l=Lock()
# m=Manager()
# num=m.dict({'money':100})
# p_out=Process(target=put_out,args=(num,l))
# p_out.start()
# p_in=Process(target=put_in,args=(num,l))
# p_in.start()
# p_in.join()
# p_out.join()
# print(num['money'])
#进程池的应用:1.map(函数,可迭代对象);2.apply(函数,参数);3.apply_async(函数,参数,回调函数)
from multiprocessing import Pool
#map引用:速度最慢
# def func(i):
# i+=1
# print(i)
# return i
#
# if __name__ == '__main__':
# p=Pool(9)
# res=p.map(func,[i for i in range(20)])
# p.close()#保证不再传进程
# p.join()#先执行子进程
# print(res)
#apply应用:同步处理,速度稍微慢,进程全为普通进程
# apply(func,args=())： 同步的效率，也就是说池中的进程一个一个的去执行任务
# func：进程池中的进程执行的任务函数
# args: 可迭代对象型的参数，是传给任务函数的参数
# 同步处理任务时，不需要close和join
# 同步处理任务时，进程池中的所有进程是普通进程（主进程需要等待其执行结束）
# def func(i):
# i+=1
# return i
#
# if __name__ == '__main__':
# p=Pool(9)
# for i in range(20):
# res=p.apply(func,args=(i,))
# print(res)#不需要close()和join()
#apply_async应用:异步处理,速度最快,进程为守护进程
# apply_async(func,args=(),callback=None)： 异步的效率，也就是说池中的进程一次性都去执行任务
# func：进程池中的进程执行的任务函数
# args: 可迭代对象型的参数，是传给任务函数的参数
# callback: 回调函数，就是说每当进程池中有进程处理完任务了，返回的结果可以交给回调函数，由回调函数进行进一步的处理,回调函数只有异步才有，同步是没有的
# 异步处理任务时，进程池中的所有进程是守护进程（主进程代码执行完毕守护进程就结束）
# 异步处理任务时，必须要加上close和join
def func(i):
i+=1
# print(i)
return i
if __name__ == '__main__':
p=Pool(9)
l=[]
for i in range(20):
res=p.apply_async(func,args=(i,))
l.append(res)
[print(i.get())for i in l]
p.close()#保证不再传进程
p.join()#先执行子进程