1、进程池
当有成千上万个任务需要被执行的时候，有了进程池我们就不必去创建大量的进程. 首先，创建进程需要消耗时间，销毁进程（空间，变量，文件信息等等的内容）也需要消耗时间, 第二即便开启了成千上万的进程，操作系统也不能让他们同时执行，维护一个很大的进程列表的同时，调度的时候，还需要进行频繁切换并且记录每个进程的执行节点, 这样反而会影响程序的效率。
创建一个有固定数量的进程池, 执行任务的时候就拿池中的进程来处理任务，等到处理完毕，进程并不关闭，而是将进程再放回进程池中继续等待任务, 可以减少创建进程的开支. 这样不会增加操作系统的调度难度，还节省了开闭进程的时间，也一定程度上能够实现并发效果.
使用进程池来实现并发效果, 减少创建进程的开支, 提高效率.
map()方法: 异步调用进程, map自带join()的功能.
import time
from multiprocessing import Pool,Process def func1(i):
numb = 0
for j in range(5):
numb += i if __name__ == '__main__': p_lst = []
s_time = time.time()
for i in range(500):
p = Process(target=func1,args=(i,))
p.start()
p_lst.append(p)
[pp.join() for pp in p_lst]
e_time = time.time()
dis_time = e_time - s_time
print("非进程池",dis_time) # 9.458896160125732 处理时间 # --------------------------------------------------------------------------------- pool = Pool(4)
ps_time = time.time()
pool.map(func1, range(100)) # 把可迭代对象的每一个元素都作为参数扔给func1
pe_time = time.time()
dis_time = pe_time - ps_time
print("进程池",dis_time) # 0.07204794883728027 处理时间
进程池map方法
apply()方法: 提供一个同步串行的方法.
import time
from multiprocessing import Pool,Process def func1(i):
numb = 0
for j in range(5):
numb += i
time.sleep(0.5)
return numb if __name__ == '__main__': pool = Pool(4) for i in range(10):
print(i)
ret = pool.apply(func1, args=(i,)) # apply提供的是一个同步串行的执行方法.
# 进程1 执行完任务后, ret 获取到数据, 第二个进程才开始执行任务. print(ret)
进程池apply同步调用
apply_async()方法: 进程池异步调用方法.
注意: 在使用进程池异步调用时, 主进程结束时, 所有的子进程也跟着一起结束了(后台全部关闭), 所以主程序必须得先 join() , 等待子进程结束.
使用apply_async()异步调用时, 主程序必须使用 join() 方法, 等待进程池内的任务都处理完, 才能用get()获取结果.
使用map()异步调用时, 不用写 join() 方法, map()会自动 join().
import time
from multiprocessing import Pool,Process def func1(i):
numb = 0
for j in range(5):
numb += i
time.sleep(1)
return numb if __name__ == '__main__': pool = Pool(4)
ret_lst = []
for i in range(10): # 相当于发布10个任务, 4个进程都过来拿任务
print(i)
res = pool.apply_async(func1,args=(i,)) # 各进程都是异步状态
ret_lst.append(res) # 这一步, 是把所有的res的执行对象都先放进列表里(包括那些没有结果的对象,
# 即使后面6个任务都没有执行,但是都是先把执行对象放进列表里) pool.close() # 不是关闭进程池, 而是结束进程池接受任务, 确保没有任务再传过来
pool.join() # 感知进程池中的任务已经结束, 只有进程池结束接收任务, 才能感知进程池中的任务结束, 所以必须加 close(). for res in ret_lst:
print(res.get()) # 前4个有结果, 用get()方法获取到结果后, 一直阻塞在后六个处,直到结果传进来执行对象中
apply_async异步调用
2、回调函数
回调函数在主进程中被执行的, 子进程执行完相应的代码后, 返回主进程去执行回调函数, 它帮我们省略了主进程自身调用函数的这一步骤.
from multiprocessing import Process,Pool def func1(n):
return n * n def call_back_func(ret): # 这里的ret 传的是func1的结果.
with open("回调内容","w") as f:
f.write(str(ret)) if __name__ == '__main__': pool = Pool(4)
ret = pool.apply_async(func1,args=(25,),callback=call_back_func)
# callback后面跟回调函数, 即把func1的结果传进callback回调函数中去执行,因为调用者拿不到
# 回调函数的返回值, 所以只能将返回值写进文件或者数据库里. print(ret.get())
进程池回调函数
3、进程间的通信
多进程共同去处理共享数据的时候，就和我们多进程同时去操作一个文件中的数据是一样的，不加锁就会出现错误的结果，进程不安全的，所以也需要加锁
数据共享----Manager模块
给Manager对象里面传入你要共享的数据, 然后操作数据时一样要上锁、解锁.
from multiprocessing import Process,Lock,Manager def func1(dic,loc):
with loc: # with loc 做了两件事: loc.acquire() 和 loc.release(), 自动上锁和解锁
dic["numb"] -= 1 if __name__ == '__main__':
m = Manager()
loc = Lock()
dic = m.dict({"numb": 100})
p_lst = []
for i in range(100):
p = Process(target=func1, args=(dic,loc))
p.start()
p_lst.append(p)
[pp.join() for pp in p_lst]
print(">>>>>>",dic["numb"])
Manager数据共享