多进程间1的通信

#队列中的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()#先执行子进程