# 进程池
#为什么要有进程池?
#在程序实际处理任务过程中,忙时会有成千上万的任务需要被执行,闲时可能只有零星任务.
#那么在成千上万个任务需要执行的时候,我们就需要去创建成千上万个进程么?
#首先,创建进程需要消耗时间,销毁进程也需要消耗时间.第二即便开启成千上万的进程
#操作系统也不能让他们同时执行,这样反而影响程序的效率.因此我们不能无限的根据
#任务开启或者任务结束.
#在这里,要给大家结束一个进程池的概念,定义好一个池子,在里面放上固定数量
#的进程,有需要来了,就在一个池子中的进程来处理任务,等到任务处理完毕,进程并不关闭
#而是将进程放回池中继续等待任务.如果有很多任务需要执行,池中进程的数量不够,任务就需要
#等待之前的进程执行任务完毕归来,拿到空闲进程才能继续执行.这样增加操作系统的调度难度
# 还节省了开闭进程的时间,也一定程度上能够实现并发效果
# multiprocessing.Pool 模块
#Pool([numprocess [,initializer [,initargs]]]):创建进程池
# 参数介绍
#numprocess:要创建的进程数,如果省略,将默认使用cpu_count()的值(这是os模块的一个方法)
#initializer:是每个工作进程启动时要执行的可调用对象,默认为None
#initargs:是要传给initializer的参数组
# 主要方法有三个:
# p = Pool
#1.p.apply(func [,args [,kwargs]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果
#注意:此操作并不会在所有池工作进程中执行func函数.如果要通过不同参数并发地执行func函数
#必须从不同线程调用p.apply()函数或者使用p.apply_async()
# 同步,只有func被执行完后才会继续执行代码,返回值为func的return值
#同步处理任务,进程池中的所有进程都是普通进程
# 2. p.map(self,func,iterable,chunksize=None):
# 异步,自带close和join,返回值为func返回组成的列表
# 3. p.apply_async(func [,args [,kwargs]]):在一个池中工作进程中执行func(*args,**kwargs)
# 然后返回结果
#此方法的结果是AsyncResult类的实例,callback是可调用对象,接收输入参数,当func的结果变为可用是
# 将结果传递给callback. callback禁止执行任何阻塞操作,否者将接收其他异步操作结果
# 异步,当func被注册进入一个进程后,程序就继续向下执行,返回一个对象,这个对象有get方法可以取到值
# obj.get()会阻塞,知道对应的func执行完毕拿到结果.需要先close和join来保持多进程和主进程的代码同步性
# 异步处理任务时,进程池中的所有进程都是守护进程
# 有回调函数 callback
# 4. p.close():关闭进程池,防止进一步操作.如果所有操作持续挂起,它们将在工作进程终止前wanc
# 5. p.join():等待所有工作进程退出.此方法只能在close()或teminate()之后调用
# 其它方法
# 1.方法apply_async()和map_async()的返回值是AsyncResul的实例obj
# 2.obj.get():返回结果,如果有必要则等待结果到达.timeout是可选的.如果
#在指定时间内还没有到达,将引发异常.如果远程操作中引发了异常,它将在调用此方法时再次被引发
# 3.obj.ready():如果调用完成,返回True
# 4.obj.successful():如果调用完成且没有引发异常,它将在调用此方法时再次被引用
# 5.obj.wait([timeout]):等待结果变为可用
# 6.obj.terminate():立即终止所有工作进程,同时不执行任何清理或结束任何挂起工作.如果p被垃圾回收
#将自动调用此函数
# p.map进程池和进程效率测试
# from multiprocessing import Pool,Process
# import os,time
#
# def func(num):
# num += 1
# print(num)
#
# if __name__ == '__main__':
# p = Pool(5) # 开进程池中进程的个数5个
# start = time.time() # 进程池中任务开始计时
# p.map(func,[i for i in range(100)]) # 进程池中的map方法
# 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()是指让进程池中的进程,异步的帮你做任务
# 结果是进程池任务呢0.13 多进程任务5.1
# 进程池的同步调用 1
# from multiprocessing import Pool,Process
# import time
#
# def func(num):
# num += 1
# return num
# def func1(num1):
# num1 -= 1
# return num1
#
# if __name__ == '__main__':
# p = Pool(5)
# start = time.time()
# for i in range(100):
# ret1 = p.apply(func1,args=(i,))
# ret = p.apply(func,args=(i,)) # 同步处理100个任务,同步指不管多少个任务都是一个一个进
# print(ret,ret1)
#
# print(time.time() - start)
# 进程池的同步调用二
# from multiprocessing import Pool
# import time,os
#
# def work(n): # 接收i的传参
# print('%s run' %os.getpid()) # 获取pid
# time.sleep(3)
# return n**2
#
# if __name__ == '__main__':
# p = Pool(5) # 进程池开5个进程
# ret_l = []
# for i in range(10):
#
# res = p.apply(work,args=(i,)) # 同步调用,直到本次任务执行完毕拿到res,任务
# print(res)
# ret_l.append(res)
# #work执行的过程中可能有阻塞也有可能没有阻塞
# #但不管该任务是否存在阻塞,同步调用都会在原地等待
# print(ret_l)
#
#
# 进程池异步处理任务
# from multiprocessing import Pool
# import time
# def func(num):
# num += 1
# return num
#
# if __name__ == '__main__':
# p = Pool(5)
# start = time.time()
# lst = []
# for i in range(100):
#
# ret = p.apply_async(func,args=(i,)) # 异步处理100个任务,异步值,进程池中有五个进程,一下可以处理五个任务
# #print(ret) # 返回 进程池对象地址通过get获取函数具体的值
# print(ret.get())
# lst.append(ret)
# p.close() #关闭
# p.join()
# #print(lst)
# for i in lst:
# new_ret = i.get() # 通过get获取结果
# #print(new_ret)
# print(time.time() - start)
#
# 进程池异步处理任务二
# from multiprocessing import Pool
# import time,os
#
# def work(n):
# print('%s run' %os.getpid())
# return n**2
#
# if __name__ == '__main__':
# p = Pool(5) # 进程池开五个进程
# ret_lst = []
# for i in range(10):
# ret = p.apply_async(work,args=(i,)) # 异步运行,根据进程池中的进程数,每次
# #最多执行5个子进程在异步执行
# #返回结果加入列表,归还进程,之后执行新任务
# #注意:进程池中的五个进程不会同时开启或者同时结束
# #而是执行完一个就释放一个进程,这个进程去接收新的任务
# ret_lst.append(ret)
# #异步apply_async用法:如果使用异步提交任务,主进行需要使用join,等待进程池内
# #任务都处理完,然后可以用get收集结果
# #否者,主进程结束,进程池可能还没来得及执行,也就跟着主进程一起结束
# p.close()
# p.join()
# for i in ret_lst:
# new_ret = i.get() # 获取结果
# #使用get来获取apply_async的结果,如果是apply,则没有get方法
# #因为apply是同步执行,立刻获取结果,也根本无需get
# print(new_ret)
# 进程池同步执行和异步执行的效率对比
# 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):
# ret = p.apply(func,args=(i,)) # 进程池同步执行
# print('进程池同比执行时间:',time.time() - start)
#
# start = time.time()
# for i in range(10000):
# ret1 = p.apply_async(func,args=(i,)) # 进程池异步执行
# p.close()
# p.join()
# print("进程池异步执行时间:",time.time() - start)
# 结果:进程池执行相同的任务量,异步执行比同步执行块
# 回调函数
#需要回调函数的场景:进程池中任何一个任务一旦处理完了,就立即告知进程
#我好了饿,你可以处理我的结果.主进程则掉用一个函数去处理该结果,该函数即会调函数
#我们可以把耗时间(阻塞)的任务放到进程池中,然后指定回调函数(主进程复杂执行)
#这样主进程在执行回调数时就省去I/O的过程,直接拿到的是任务的结果
#如果在主进程中等待进程池中所有任务都执行完毕后,再统一处理结果,则无需回调函数
