一、进程池。
当并发的任务数量远远大于计算机所能承受的范围，即无法一次性开启过多的任务数量就应该考虑去 限制进程数或线程数，从而保证服务器不会因超载而瘫痪。这时候就出现了进程池和线程池。
二、concurrent.futures模块介绍
concurrent.futures模块提供了高度封装的异步调用接口
ThreadPoolExecutor：线程池，提供异步调用
ProcessPoolExecutor：进程池，提供异步调用
Both implement the same interface, which is defined by the abstract Executor class
三、基本方法：
submit(fn, *args, **kwargs)：异步提交任务
map(func, *iterables, timeout=None, chunksize=1)：取代for循环submit的操作
shutdown(wait=True)：相当于进程池的pool.close()+pool.join()操作
- wait=True，等待池内所有任务执行完毕回收完资源后才继续
- wait=False，立即返回，并不会等待池内的任务执行完毕
- 但不管wait参数为何值，整个程序都会等到所有任务执行完毕
- submit和map必须在shutdown之前
result(timeout=None)：取得结果
add_done_callback(fn)：回调函数
done()：判断某一个线程是否完成
cancle()：取消某个任务
四、进程池代码实例——ProcessPoolExecutor
from concurrent.futures import ProcessPoolExecutor
from multiprocessing import current_process
import time
def func(i):
print(f'进程 {current_process().name} 正在执行任务 {i}')
time.sleep(1)
return i**2
if __name__ == '__main__':
pool = ProcessPoolExecutor(4) # 进程池只有4个进程
lt = []
for i in range(20): # 假设执行20个任务
future = pool.submit(func,i) # func任务要做20次,4个进程负责完成这个20个任务
# print(future.result()) # 如果没有结果就一直等待拿到结果，导致了所有任务都在串行
lt.append(future)
pool.shutdown() # 默认为True,关闭了池的入口，会等待所有的任务执行完，结束阻塞，
for fu in lt:
print(fu.result()) # 等待所有的任务都执行完了，一起把返回值打印出来
五、线程池代码示例——ThreadPoolExecutor
from concurrent.futures import ThreadPoolExecutor
from threading import currentThread
import time
def func(i):
print(f'线程 {currentThread().name} 正在执行任务 {i}')
time.sleep(1)
return i**2
if __name__ == '__main__':
fool = ThreadPoolExecutor(4) # 线程池里只有4个线程
lt = []
for i in range(20):
futrue = fool.submit(func,i) # func任务要做20次，4个线程负责完成这20次任务
lt.append(futrue)
fool.shutdown() # 默认为True,关闭了池的入口，会等待所有的任务执行完，结束阻塞，
for fu in lt:
print(fu.result()) # 等待所有的任务都执行完了，一起把返回值打印出来
六、回调函数add_done_callback(fn)
提交任务的两种方式：
同步： 提交了一个任务，必须等任务执行完了（拿到返回值），才能执行下一行代码
异步： 提交了一个任务，不要等执行完了，可以直接执行下一行代码。
ps:进程和线程回调方法的使用写一块了，注释掉的是进程的使用。
from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
from threading import currentThread
from multiprocessing import current_process
import time
def task(i):
print(f'线程 {currentThread().name} 正在执行任务 {i}')
# print(f'进程 {current_process().name} 正在执行任务 {i}')
time.sleep(1)
return i**2
def parse(futrue):
# 处理拿到的结果
print(futrue.result())
if __name__ == '__main__':
pool = ThreadPoolExecutor(4) # 线程池里只有4个线程
# pool = ProcessPoolExecutor(4) # 进程池里只有4个进程
lt = []
for i in range(20):
futrue = pool.submit(task,i) # task任务要做20次，分别由四个进程完成这20个任务
futrue.add_done_callback(parse)
# 为当前任务绑定一个函数，在当前任务执行结束的时候会触发这个函数
# 会把futrue对象作为参数传给函数
# 这个称之为回调函数，处理完了回来就调用这个函数。
跟上面线程池里的例子相比：回调函数的作用，不需要等待所有的任务执行完才打印返回值。每执行完一个任务直接打印结果，实现一个并发的效果，效率有所提升。