python进程池概念_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的过程,直接拿到的是任务的结果

#如果在主进程中等待进程池中所有任务都执行完毕后,再统一处理结果,则无需回调函数