Python进程池

#  进程池
#为什么要有进程池?
    #在程序实际处理任务过程中,忙时会有成千上万的任务需要被执行,闲时可能只有零星任务.
#那么在成千上万个任务需要执行的时候,我们就需要去创建成千上万个进程么?
#首先,创建进程需要消耗时间,销毁进程也需要消耗时间.第二即便开启成千上万的进程
#操作系统也不能让他们同时执行,这样反而影响程序的效率.因此我们不能无限的根据
#任务开启或者任务结束.
    #在这里,要给大家结束一个进程池的概念,定义好一个池子,在里面放上固定数量
#的进程,有需要来了,就在一个池子中的进程来处理任务,等到任务处理完毕,进程并不关闭
#而是将进程放回池中继续等待任务.如果有很多任务需要执行,池中进程的数量不够,任务就需要
#等待之前的进程执行任务完毕归来,拿到空闲进程才能继续执行.这样增加操作系统的调度难度
# 还节省了开闭进程的时间,也一定程度上能够实现并发效果

#  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的过程,直接拿到的是任务的结果
    #如果在主进程中等待进程池中所有任务都执行完毕后,再统一处理结果,则无需回调函数