（转）理解Python并发编程一篇就够了

关于python并发编程，转一篇好文，链接：https://mp.weixin.qq.com/s/Xdggv8YkhTuuQieLTapqHA

之前我们使用多线程(threading)和多进程(multiprocessing)完成常规的需求，在启动的时候start、jon等步骤不能省，复杂的需要还要用1-2个队列。随着需求越来越复杂，如果没有良好的设计和抽象这部分的功能层次，代码量越多调试的难度就越大。有没有什么好的方法把这些步骤抽象一下呢，让我们不关注这些细节，轻装上阵呢？

答案是：有的。

从Python3.2开始一个叫做concurrent.futures被纳入了标准库，而在Python2它属于第三方的futures库，需要手动安装：

  1. ❯ pip install futures

这个模块中有2个类：ThreadPoolExecutor和ProcessPoolExecutor，也就是对threading和multiprocessing的进行了高级别的抽象， 暴露出统一的接口，帮助开发者非常方便的实现异步调用：

  1. import time

  2. from concurrent.futures import ProcessPoolExecutor, as_completed

  3.  

  4. NUMBERS = range(25, 38)

  5.  

  6.  

  7. def fib(n):

  8.    if n<= 2:

  9.        return 1

  10.    return fib(n-1) + fib(n-2)

  11.  

  12.  

  13. start = time.time()

  14.  

  15. with ProcessPoolExecutor(max_workers=3) as executor:

  16.    for num, result in zip(NUMBERS, executor.map(fib, NUMBERS)):

  17.        print 'fib({}) = {}'.format(num, result)

  18.  

  19. print 'COST: {}'.format(time.time() - start)

感受下是不是很轻便呢？看一下花费的时间：

  1. ❯ python fib_executor.py

  2. fib(25) = 75025

  3. fib(26) = 121393

  4. fib(27) = 196418

  5. fib(28) = 317811

  6. fib(29) = 514229

  7. fib(30) = 832040

  8. fib(31) = 1346269

  9. fib(32) = 2178309

  10. fib(33) = 3524578

  11. fib(34) = 5702887

  12. fib(35) = 9227465

  13. fib(36) = 14930352

  14. fib(37) = 24157817

  15. COST: 10.8920350075

除了用map，另外一个常用的方法是submit。如果你要提交的任务的函数是一样的，就可以简化成map。但是假如提交的任务函数是不一样的，或者执行的过程之可能出现异常（使用map执行过程中发现问题会直接抛出错误）就要用到submit：

  1. from concurrent.futures import ThreadPoolExecutor, as_completed

  2.  

  3. NUMBERS = range(30, 35)

  4.  

  5.  

  6. def fib(n):

  7.    if n == 34:

  8.        raise Exception("Don't do this")

  9.    if n<= 2:

  10.        return 1

  11.    return fib(n-1) + fib(n-2)

  12.  

  13.  

  14. with ThreadPoolExecutor(max_workers=3) as executor:

  15.    future_to_num = {executor.submit(fib, num): num for num in NUMBERS}

  16.    for future in as_completed(future_to_num):

  17.        num = future_to_num[future]

  18.        try:

  19.            result = future.result()

  20.        except Exception as e:

  21.            print 'raise an exception: {}'.format(e)

  22.        else:

  23.            print 'fib({}) = {}'.format(num, result)

  24.  

  25.  

  26. with ThreadPoolExecutor(max_workers=3) as executor:

  27.    for num, result in zip(NUMBERS, executor.map(fib, NUMBERS)):

  28.        print 'fib({}) = {}'.format(num, result)

执一下：

  1. ❯ python fib_executor_with_raise.py

  2. fib(30) = 832040

  3. fib(31) = 1346269

  4. raise an exception: Don't do this

  5. fib(32) = 2178309

  6. fib(33) = 3524578

  7. Traceback (most recent call last):

  8.  File "fib_executor_with_raise.py", line 28, in <module>

  9.    for num, result in zip(NUMBERS, executor.map(fib, NUMBERS)):

  10.  File "/Library/Python/2.7/site-packages/concurrent/futures/_base.py", line 580, in map

  11.    yield future.result()

  12.  File "/Library/Python/2.7/site-packages/concurrent/futures/_base.py", line 400, in result

  13.    return self.__get_result()

  14.  File "/Library/Python/2.7/site-packages/concurrent/futures/_base.py", line 359, in __get_result

  15.    reraise(self._exception, self._traceback)

  16.  File "/Library/Python/2.7/site-packages/concurrent/futures/_compat.py", line 107, in reraise

  17.    exec('raise exc_type, exc_value, traceback', {}, locals_)

  18.  File "/Library/Python/2.7/site-packages/concurrent/futures/thread.py", line 61, in run

  19.    result = self.fn(*self.args, **self.kwargs)

  20.  File "fib_executor_with_raise.py", line 9, in fib

  21.    raise Exception("Don't do this")

  22. Exception: Don't do this

可以看到，第一次捕捉到了异常，但是第二次执行的时候错误直接抛出来了。

上面说到的map，有些同学马上会说，这不是进程（线程）池的效果吗？看起来确实是的：

  1. import time

  2. from multiprocessing.pool import Pool

  3.  

  4. NUMBERS = range(25, 38)

  5.  

  6.  

  7. def fib(n):

  8.    if n<= 2:

  9.        return 1

  10.    return fib(n-1) + fib(n-2)

  11.  

  12.  

  13. start = time.time()

  14.  

  15. pool = Pool(3)

  16. results = pool.map(fib, NUMBERS)

  17. for num, result in zip(NUMBERS, pool.map(fib, NUMBERS)):

  18.    print 'fib({}) = {}'.format(num, result)

  19.  

  20. print 'COST: {}'.format(time.time() - start)

好像代码量更小哟。好吧，看一下花费的时间：

  1. ❯ python fib_pool.py

  2. fib(25) = 75025

  3. fib(26) = 121393

  4. fib(27) = 196418

  5. fib(28) = 317811

  6. fib(29) = 514229

  7. fib(30) = 832040

  8. fib(31) = 1346269

  9. fib(32) = 2178309

  10. fib(33) = 3524578

  11. fib(34) = 5702887

  12. fib(35) = 9227465

  13. fib(36) = 14930352

  14. fib(37) = 24157817

  15. COST: 17.1342718601

WhatTF竟然花费了1.7倍的时间。为什么？

BTW，有兴趣的同学可以对比下ThreadPool和ThreadPoolExecutor，由于GIL的缘故，对比的差距一定会更多。

原理

我们就拿ProcessPoolExecutor介绍下它的原理，引用官方代码注释中的流程图：

我们结合源码和上面的数据流分析一下：

  1. executor.map会创建多个_WorkItem对象，每个对象都传入了新创建的一个Future对象。

  2. 把每个_WorkItem对象然后放进一个叫做「Work Items」的dict中，键是不同的「Work Ids」。

  3. 创建一个管理「Work Ids」队列的线程「Local worker thread」，它能做2件事：

    1. 从「Work Ids」队列中获取Work Id, 通过「Work Items」找到对应的_WorkItem。如果这个Item被取消了，就从「Work Items」里面把它删掉，否则重新打包成一个_CallItem放入「Call Q」这个队列。executor的那些进程会从队列中取_CallItem执行，并把结果封装成_ResultItems放入「Result Q」队列中。

    2. 从「Result Q」队列中获取_ResultItems，然后从「Work Items」更新对应的Future对象并删掉入口。

看起来就是一个「生产者/消费者」模型罢了，错了。我们要注意，整个过程并不是多个进程与任务+结果-2个队列直接通信的，而是通过一个中间的「Local worker thread」，它就是让效率提升的重要原因之一！！！

设想，当某一段程序提交了一个请求，期望得到一个答复。但服务程序对这个请求可能很慢，在传统的单线程环境下，调用函数是同步的，也就是说它必须等到服务程序返回结果后，才能进行其他处理。而在Future模式下，调用方式改为异步，而原先等待返回的时间段，在主调用函数中，则可用于处理其他事物。

Future

Future是常见的一种并发设计模式，在多个其他语言中都可以见到这种解决方案。

一个Future对象代表了一些尚未就绪（完成）的结果，在「将来」的某个时间就绪了之后就可以获取到这个结果。比如上面的例子，我们期望并发的执行一些参数不同的fib函数，获取全部的结果。传统模式就是在等待queue.get返回结果，这个是同步模式，而在Future模式下，调用方式改为异步，而原先等待返回的时间段，由于「Local worker thread」的存在，这个时候可以完成其他工作

在tornado中也有对应的实现。2013年的时候，我曾经写过一篇博客使用tornado让你的请求异步非阻塞，最后也提到了用concurrent.futures实现异步非阻塞的完成耗时任务。

PS：本文全部代码可以在微信公众号文章代码库项目中找到。

posted @ 2019-12-30 17:09  景木  阅读(77)  评论(0)    收藏  举报