concurrent.futures- 启动并行任务
python因为其全局解释器锁GIL而无法通过线程实现真正的平行计算。这个论断我们不展开，但是有个概念我们要说明，IO密集型 vs. 计算密集型。
IO密集型：读取文件，读取网络套接字频繁。
计算密集型：大量消耗CPU的数学与逻辑运算，也就是我们这里说的平行计算。
而concurrent.futures模块，可以利用multiprocessing实现真正的平行计算。
核心原理是：concurrent.futures会以子进程的形式，平行的运行多个python解释器，从而令python程序可以利用多核CPU来提升执行速度。由于子进程与主解释器相分离，所以他们的全局解释器锁也是相互独立的。每个子进程都能够完整的使用一个CPU内核。
一、初体验
Future总结
1. python3自带，python2需要安装 2. Executer对象 它是一个抽象类，它提供了异步执行的方法，他不能直接使用，但可以通过它的子类 ThreadPoolExecuter和ProcessPoolExecuter 2.1 Executer.submit(fn,*args,**kwargs) fn:需要异步执行的函数 *args,**kwargs fn接受的参数 该方法的作用就是提交一个可执行的回调task，它返回一个Future对象 2.2 map(fn,*iterables, timeout=None, chunksize=1) map(task,URLS) # 返回一个map()迭代器，这个迭代器中的回调执行返回的结果是有序的 3. Future对象相关 future可以理解为一个在未来完成的操作，这是异步编程的基础 通常情况下我们在遇到IO操作的时候，将会发生阻塞，cpu不能做其他事情 而future的引入帮助我们在这段等待时间可以完成其他的操作 3.1 done(): 如果当前线程已取消/已成功，返回True。 3.2 cance(): 如果当前线程正在执行，并且不能取消调用，返回Flase。否则调用取消，返回True 3.3 running(): 如果当前的线程正在执行，则返回True 3.4 result(): 返回调用返回的值，如果调用尚未完成，则此方法等待 如果等待超时，会抛出concurrent.futures.TimeoutError 如果没有指定超时时间，则等待无时间限制 如果在完成之前，取消了Future，则会引发CancelledError 4. as_completed(): 在多个Future实例上的迭代器将会被返回 这些Future实例由fs完成时产生。 由fs返回的任何重复的Future，都会被返回一次。 里面保存的都是已经执行完成的Future对象 5. wait(): 返回一个元祖，元祖包含两个元素 1. 已完成的future集合 2. 未完成的future集合
初体验
# coding=utf-8 from concurrent import futures from concurrent.futures import Future import time def return_future(msg): time.sleep(3) return msg pool = futures.ThreadPoolExecutor(max_workers=2) t1 = pool.submit(return_future,'hello') t2 = pool.submit(return_future,'world') time.sleep(3) print(t1.done()) # 如果顺利完成，则返回True time.sleep(3) print(t2.done()) print(t1.result()) # 获取future的返回值 time.sleep(3) print(t2.result()) print("主线程")
map（func，* iterables，timeout = None，chunksize = 1 ）
# coding=utf-8 import time from concurrent.futures import Future,as_completed from concurrent.futures import ThreadPoolExecutor as Pool import requests import time URLS = ['http://www.baidu.com', 'http://qq.com', 'http://sina.com'] def task(url,timeout=10): return requests.get(url=url,timeout=timeout) pool = Pool() result = pool.map(task,URLS) start_time = time.time() # 按照URLS的顺序返回 for res in result: print("{} {}".format(res.url,len(res.content))) # 无序的 with Pool(max_workers=3) as executer: future_task = [executer.submit(task,url) for url in URLS] for f in as_completed(future_task): if f.done(): f_ret = f.result() # f.result()得到task的返回值，requests对象 print('%s, done, result: %s, %s' % (str(f), f_ret.url, len(f_ret.content))) print("耗时",time.time() - start_time) print("主线程")
二、Future对象
Future可以理解为一个未来完成的操作
当我们执行io操作的时候，在等待返回结果之前会产生阻塞
cpu不能做其他事情，而Future的引入帮助我们在等待的这段时间可以完成其他操作
from concurrent.futures import ThreadPoolExecutor as Pool from concurrent.futures import as_completed import requests import time URLS = ['http://www.baidu.com', 'http://qq.com', 'http://sina.com'] def task(url,timeout=10): return requests.get(url=url,timeout=timeout) # start_time = time.time() # for url in URLS: # ret = task(url) # print("{} {}".format(ret.url,len(ret.content))) # print("耗时",time.time() - start_time) with Pool(max_workers=3) as executor: # 创建future任务 future_task = [executor.submit(task,url) for url in URLS] for f in future_task: if f.running(): print("%s is running"%str(f)) for f in as_completed(future_task): try: ret = f.done() if ret: f_ret = f.result() print('%s, done, result: %s, %s' % (str(f), f_ret.url, len(f_ret.content))) except Exception as e: f.cance() print(e) """ url不是按照顺序返回的，说明并发时，当访问某一个url时，如果没有得到返回结果，不会发生阻塞 <Future at 0x1c63990e6d8 state=running> is running <Future at 0x1c639922780 state=running> is running <Future at 0x1c639922d30 state=running> is running <Future at 0x1c63990e6d8 state=finished returned Response>, done, result: http://www.baidu.com/, 2381 <Future at 0x1c639922780 state=finished returned Response>, done, result: https://www.qq.com?fromdefault, 243101 <Future at 0x1c639922d30 state=finished returned Response>, done, result: http://sina.com/, 23103 """
三、模块方法
concurrent.futures.wait(fs, timeout=None, return_when=ALL_COMPLETED)
wait()会返回一个tuple，
tuple会包含两个集合
1. 已完成的集合
2. 未完成的集合
使用wait()会获得更大的自由度，他接受三个参数
FIRST_COMPLETED, FIRST_EXCEPTION和ALL_COMPLETE
默认为ALL_COMPLETE
from concurrent.futures import Future from concurrent.futures import ThreadPoolExecutor as Pool from concurrent.futures import as_completed,wait import requests URLS = ['http://www.baidu.com', 'http://qq.com', 'http://sina.com'] def task(url,timeout=10): return requests.get(url=url,timeout=timeout) with Pool(max_workers=3) as execute : fulture_task = [execute.submit(task,url) for url in URLS] for f in fulture_task: if f.running(): print("%s"%(str(f))) """ 并且wait还有timeout和return_when两个参数 return_when有三个常量 FIRST_COMPLETED 任何一个future_task执行完成时/取消时，改函数返回 FIRST_EXCEPTION 任何一个future_task发生异常时，该函数返回，如果没有异常发生，等同于ALL_COMPLETED ALL_COMPLETED 当所有的future_task执行完毕返回 """ results = wait(fulture_task,return_when="FIRST_COMPLETED")# done = results[0] for d in done: print(d)
concurrent.futures.as_completed(fs, timeout=None)
在多个Future实例上的迭代器将会被返回
这些Future实例由fs完成时产生。
由fs返回的任何重复的Future，都会被返回一次。
里面保存的都是已经执行完成的Future对象
from concurrent.futures import ThreadPoolExecutor as Pool from concurrent.futures import as_completed import requests import time URLS = ['http://www.baidu.com', 'http://qq.com', 'http://sina.com'] def task(url,timeout=10): return requests.get(url=url,timeout=timeout) with Pool(max_workers=3) as executor: # 创建future任务 future_task = [executor.submit(task,url) for url in URLS] for f in future_task: if f.running(): print("%s is running"%str(f)) for f in as_completed(future_task): try: ret = f.done() if ret: f_ret = f.result() print('%s, done, result: %s, %s' % (str(f), f_ret.url, len(f_ret.content))) except Exception as e: f.cance() print(e)
