ProcessPoolExecutor 进程池执行器类是 Executor 执行器类的子类，使用进程池来异步执行调用。
ProcessPoolExecutor 使用了 multiprocessing 模块，这允许它可以规避 Global Interpreter Lock，但是也意味着只能执行和返回可序列化的（picklable）对象。

__main__ 模块必须被 worker 子进程导入，这意味着 ProcessPoolExecutor 在交互解释器中无法工作。

在已经被提交到 ProcessPoolExecutor 中的可调用对象内使用 Executor 或者 Future 方法会导致死锁。

concurrent.futures.ProcessPoolExecutor(max_workers=None, mp_context=None, initializer=None, initargs=())

这个 Executor 子类最多用 max_workers 个进程来异步执行调用。
如果不指定 max_workers 或者为 None，它默认为本机的处理器数量。
如果 max_workers 小于等于 0，会抛出 ValueError 异常。
mp_context 是多进程上下文（multiprocessing context）或者 None，它会被用来启动 workers。如果不指定 mp_context 或者为 None，会使用默认的多进程上下文环境。

initializer 是一个可选的可调用对象，会在每个 worker 进程启动之前调用。
initargs 是传递给 initializer 的参数元组。
如果 initializer 抛出了异常，那么当前所有等待的任务都会抛出 BrokenProcessPool 异常，继续提交 submit 任务也会抛出此异常。

Future 类封装了可调用对象的异步执行。
Future 实例通过 Executor.submit() 创建。

concurrent.futures.Future

封装了可调用对象的异步执行。

exception(timeout=None)
返回被调用抛出的异常。如果调用还没有执行完毕，则最多等待 timeout 秒。如果 timeout 秒之后还没有完成，抛出 concurrent.futures.TimeoutError。timeout 可以为整数或者浮点数。如果不指定或者为 None，则不限制等待时间。
如果 future 在完成之前被取消了，会抛出 CancelledError 异常。
如果调用完成并且没有抛出异常，返回 None。

concurrent.futures.wait(fs, timeout=None, return_when=ALL_COMPLETED)

等待 Future 实例完成，这些实例可能由多个不同的执行器实例创建，通过 fs 指定这些 Future 实例。返回具名元组，该元组有两个元素，每个元素都是一个集合。第一个元素名叫 done，该集合包括已完成的 futures；第二个元素名叫 not_done，该集合包括未完成的 futures。
timeout 用来控制返回之前等待的最大秒数，可以是整数或者浮点数。如果不指定或为 None，不限制等待时间。
return_when 指明函数何时应该返回。它必须是下列常量之一：

concurrent.futures.as_completed(fs, timeout=None)

当通过 fs 指定的 Future 实例全部执行完毕或者被取消后，返回这些 Future 实例组成的迭代器。fs 中的 Future 实例可以被不同的执行器创建。任何在 as_completed() 调用之前就已经完成的 Future 实例会被最先生成。

查看源码发现，实际上这是一个用到了 yield from 的生成器函数，所以调用返回一个生成器。

如果从 as_completed() 调用开始，经过 timeout 秒之后，对返回的迭代器调用 __next__() 时结果仍不可用，则会抛出 concurrent.futures.TimeoutError 异常。timeout 可以是整数或者浮点数，如果 timeout 没有指定或者为 None，则不限制等待时间。

import concurrent.futures
import random
import time
URLS = ['http://www.foxnews.com/',
        'http://www.cnn.com/',
        'http://europe.wsj.com/',
        'http://www.bbc.co.uk/',
        'url',
        'http://some-made-up-domain.com/']
class CrawlerFramework(object):
    def a(self, url):
        # print(url)
        time.sleep(random.random())
        return "ok"
if __name__ == "__main__":
    crawler_framework = CrawlerFramework()
    with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
    with concurrent.futures.ProcessPoolExecutor(max_workers=10) as executor:
        future = executor.submit(crawler_framework.a, URLS[0])  # 单个
            print(future.result())  # 获取异步返回的结果,这里看到这个异步是否报错
        except Exception as e:
            print("异步执行错误:{}".format(e))
    with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
    with concurrent.futures.ProcessPoolExecutor(max_workers=10) as executor:
        future_to_url = {executor.submit(crawler_framework.a, url): url for url in URLS}  # 多个
        for future in concurrent.futures.as_completed(future_to_url):
                url = future_to_url[future]  # 获取传入异步调用函数的参数
                data = future.result()  # 获取异步返回的结果,这里看到这个异步是否报错
                print(url)
                print(data)
            except Exception as e:
                print("异步执行错误:{}".format(e))
    with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
    with concurrent.futures.ProcessPoolExecutor(max_workers=10) as executor:
        future_to_url = executor.map(crawler_framework.a, URLS)  # 多个
            print(future_to_url.__next__())  # 获取异步返回的结果,这里看到这个异步是否报错
        except Exception as e:
            print("异步执行错误:{}".format(e))

import concurrent.futures
with concurrent.futures.ThreadPoolExecutor(max_workers=30) as executor:
   future_to_url = executor.map(self.business_query, cur.fetchall())
       print(future_to_url.__next__())  # 获取异步返回的结果,这里看到这个异步是否报错
   except Exception as e:
       print("异步执行错误:{}".format(e))
with concurrent.futures.ProcessPoolExecutor(max_workers=30) as executor:
   future_to_url = executor.map(sy_zc_crawler.parse_yaml, path_list)
       print(future_to_url.__next__())  # 获取异步返回的结果,这里看到这个异步是否报错
   except Exception as e:
       print("异步执行错误:{}".format(e))