python并发 1：使用 futures 处理并发

最新推荐文章于 2023-11-24 16:55:48 发布
最新推荐文章于 2023-11-24 16:55:48 发布
阅读量227 收藏
点赞数

作为Python程序员，平时很少使用并发编程，偶尔使用也只需要派生出一批独立的线程，然后放到队列中，批量执行。所以，不夸张的说，虽然我知道线程、进程、并行、并发的概念，但每次使用的时候可能还需要再打开文档回顾一下。

现在这一篇还是 《流畅的python》读书笔记，译者在这里把future 翻译为“期物”，我觉得不太合适，既然future不能找到一个合适的词汇，暂时还是直接使用 future 吧。

concurrent.futures

future 是一种对象，表示异步执行的操作。这个概念是 concurrent.futures模块和asyncio包的基础。

concurrent.futures 模块是Python3.2 引入的，对于Python2x 版本，Python2.5 以上的版本可以安装 futures 包来使用这个模块。

从Python3.4起，标准库中有两个为Future的类：concurrent.futures.Future 和 asyncio.Future。这两个类作用相同：两个Future类的实例都表示可能已经完成或未完成的延迟计算。

Future 封装待完成的操作，可放入队列，完成的状态可以查询，得到结果（或抛出异常）后可以获取结果（或异常）。

我们知道，如果程序中包含I/O操作，程序会有很高的延迟，CPU会处于等待状态，这时如果我们不使用并发会浪费很多时间。

示例

我们先举个例子：

下边是有两段代码，主要功能都是从网上下载人口前20的国际的国旗：

运行分别运行两段代码3次，结果如下：

images.py 的结果如下

$ python flags.py
BD BR CD CN DE EG ET FR ID IN IR JP MX NG PH PK RU TR US VN 
20 flags downloaded in 6.18s

$ python flags.py
BD BR CD CN DE EG ET FR ID IN IR JP MX NG PH PK RU TR US VN 
20 flags downloaded in 5.67s

$ python flags.py
BD BR CD CN DE EG ET FR ID IN IR JP MX NG PH PK RU TR US VN 
20 flags downloaded in 6.55s

可以看到，依次下载10张图片，平均需要6秒

flags_threadpool.py 的结果如下：

$ python flags_threadpool.py
NG EG VN BR JP FR DE CN TR BD PK MX PH US RU IN ET CD ID IR 
20 flags downloaded in 2.12s

$ python flags_threadpool.py
BR IN DE FR TR RU EG NG JP CN ID ET PK MX PH US IR CD VN BD 
20 flags downloaded in 2.23s

$ python flags_threadpool.py
CN BR DE ID NG RU TR IN MX US IR BD VN CD PH EG FR JP ET PK 
20 flags downloaded in 1.18s

使用 concurrent.futures 后，下载10张图片平均需要2秒

通过上边的结果我们发现使用 concurrent.futures 后，下载效率大幅提升。

下边我们来看下这两段代码。

同步执行的代码flags.py：

#! -*- coding: utf-8 -*-

import osimport time
import sys
import requests

POP20_CC = ('CN IN US ID BR PK NG BD RU JP '
            'MX PH VN ET EG DE IR TR CD FR').split()

BASE_URL = 'http://flupy.org/data/flags'
DEST_DIR = 'images/'

# 保存图片
def save_flag(img, filename):
    path = os.path.join(DEST_DIR, filename)    
    with open(path, 'wb') as fp:
        fp.write(img)

# 下载图片
def get_flag(cc):  # <6>
    url = '{}/{cc}/{cc}.gif'.format(BASE_URL, cc=cc.lower())
    # 这里我们使用 requests 包，需要先通过pypi安装
    resp = requests.get(url)
    return resp.content
    
# 显示一个字符串，然后刷新sys.stdout,目的是在一行消息中看到进度
def show(text):  # <7>
    print(text, end=' ')
    sys.stdout.flush()def download_many(cc_list):  # <8>
    for cc in sorted(cc_list):  # <9>
        image = get_flag(cc)
        show(cc)
        save_flag(image, cc.lower() + '.gif')
    return len(cc_list)
    
def main(download_many):
    t0 = time.time()
    count = download_many(POP20_CC)
    elapsed = time.time() - t0
    msg = '\n{} flags downloaded in {:.2f}s'
    print(msg.format(count, elapsed))

if __name__ == '__main__':
    main(download_many)

使用 concurrent.future 并发的代码 flags_threadpool.py

#! -*- coding: utf-8 -*-

from concurrent import futures
from flags import save_flag, get_flag, show, main

# 设定ThreadPoolExecutor 类最多使用几个线程
MAX_WORKERS = 20


# 下载一个图片
def download_one(cc):
    image = get_flag(cc)
    show(cc)
    save_flag(image, cc.lower() + '.gif')
    return cc
    
def download_many(cc_list):
    # 设定工作的线程数量，使用约需的最大值与要处理的数量直接较小的那个值，以免创建多余的线程
    workers = min(MAX_WORKERS, len(cc_list))
    # 使用工作的线程数实例化ThreadPoolExecutor类；
    # executor.__exit__方法会调用executor.shutdown(wait=True)方法，
    # 它会在所有线程都执行完毕前阻塞线程
    with futures.ThreadPoolExecutor(workers) as executor:  # <5>
        # map 与内置map方法类似，不过download_one 函数会在多个线程中并发调用；
        # map 方法返回一个生成器，因此可以迭代，
        # 迭代器的__next__方法调用各个Future 的 result 方法
        res = executor.map(download_one, sorted(cc_list))
    # 返回获取的结果数量；如果有现成抛出异常，会在这里抛出
    # 这与隐式调用next() 函数从迭代器中获取相应的返回值一样。
    return len(list(res))  # <7>
    return len(results)
    
if __name__ == '__main__':
    main(download_many)

上边的代码，我们对 concurrent.futures 的使用有了大致的了解。但 future 在哪里呢，我们并没有看到。

Future 是 concurrent.futures 模块和 asyncio 包的重要组件。从Python3.4起，标准库中有两个为Future的类：concurrent.futures.Future 和 asyncio.Future。这两个Future作用相同。

Future 封装待完成的操作，可放入队列，完成的状态可以查询，得到结果（或抛出异常）后可以获取结果（或异常）。

例如，调用Executor.submit() 方法的参数是一个可调用的对象，调用这个方法后会为传入的可调用对象排期，并返回一个Future。

Future 有三个重要的方法：

  • .done()  返回布尔值，表示Future 是否已经执行

  • .add_done_callback() 这个方法只有一个参数，类型是可调用对象，Future运行结束后会回调这个对象。

  • .result() 如果 Future 运行结束后调用result(), 会返回可调用对象的结果或者抛出执行可调用对象时抛出的异常，如果是 Future 没有运行结束时调用 f.result()方法，这时会阻塞调用方所在的线程，直到有结果返回。此时result 方法还可以接收 timeout 参数，如果在指定的时间内 Future 没有运行完毕，会抛出 TimeoutError 异常。

asyncio.Future.result 方法不支持设定超时时间，如果想获取 Future 的结果，可以使用 yield from 结构

为了加深对 Future 的理解，现在我们修改下 flags_threadpool.py download_many 函数。

def download_many(cc_list):
    cc_list = cc_list[:5]
    with futures.ThreadPoolExecutor(max_workers=3) as executor:
        to_do = []        
        # 用于创建并排定 future
        for cc in sorted(cc_list):
            # submit 方法排定可调用对象的执行时间然后返回一个future，表示这个待执行的操作
            future = executor.submit(download_one, cc)
            to_do.append(future)
            msg = 'Scheduled for {}: {}'
            print(msg.format(cc, future))

        results = []
        # 用于获取future 结果
        # as_completed 接收一个future 列表，返回值是一个迭代器，在运行结束后产出future
        for future in futures.as_completed(to_do):
            res = future.result()
            msg = '{} result: {!r}'
            print(msg.format(future, res))
            results.append(res)
    return len(results)

现在执行代码，运行结果如下：

Scheduled for BR: <Future at 0x10d43cb70 state=running>
Scheduled for CN: <Future at 0x10d4434a8 state=running>
Scheduled for ID: <Future at 0x10d443ef0 state=running>
Scheduled for IN: <Future at 0x10d443978 state=pending>
Scheduled for US: <Future at 0x10d44f748 state=pending>
BR <Future at 0x10d43cb70 state=finished returned str> result: 'BR'
IN <Future at 0x10d443978 state=finished returned str> result: 'IN'
CN <Future at 0x10d4434a8 state=finished returned str> result: 'CN'
ID <Future at 0x10d443ef0 state=finished returned str> result: 'ID'
US <Future at 0x10d44f748 state=finished returned str> result: 'US'

5 flags downloaded in 1.47s

从结果可以看到，future 的 repr() 方法会显示状态，前三个 是running 是因为我们设定了三个进程，所以后两个是pendding 状态。如果将max_workers参数设置为5，结果就会全都是 running。

虽然，使用 future 的脚步比第一个脚本的执行速度快了很多，但由于受GIL的限制，下载并不是并行的。

GIL（Global Interpreter Lock）和阻塞型I/O

CPython 解释器本身不是线程安全的，因此解释器被一个全局解释器锁保护着，它确保任何时候都只有一个Python线程执行。

然而，Python标准库中所有执行阻塞型I/O操作的函数，在等待系统返回结果时都会释放GIL。这意味着I/O密集型Python程序能从中受益：一个Python线程等待网络响应时，阻塞型I/O函数会释放GIL，再运行一个线程。

Python 标准库中所有阻塞型I/O函数都会释放GIL，允许其他线程运行。time.sleep()函数也会释放GIL。

那么如何在CPU密集型作业中使用 concurrent.futures 模块绕开GIL呢？

答案是 使用 ProcessPoolExecutor 类。

使用这个模块可以在做CPU密集型工作是绕开GIL，利用所有可用核心。

ThreadPoolExecutor 和 ProcessPoolExecutor 都实现了通用的 Executor 接口，所以，我们可以轻松的将基于线程的方案改为使用进程的方案。

比如下边这样：

def download_many(cc_list):
    workers = min(MAX_WORKERS, len(cc_list))
    with futures.ThreadPoolExecutor(workers) as executor:
        pass


# 改成
def download_many(cc_list):
    with futures.ProcessPoolExecutor() as executor:        
        pass

需要注意的是，ThreadPoolExecutor 需要指定 max_workers 参数，

ProcessPoolExecutor 的价值主要体现在CPU密集型作业上。

使用Python处理CPU密集型工作，应该试试PyPy，会有更高的执行速度。

现在我们回到开始的代码，看下 Executor.map 函数。

文档中对map函数的介绍如下。

map(func, *iterables, timeout=None, chunksize=1)

等同于 map(func, *iterables)，不同的是 func 是异步执行的，并且可以同时进行对 func 的多个调用。如果调用 next()，则返回的迭代器提出 concurrent.futures.TimeoutError，并且在从 Executor.map() 的原始调用起的 timeout 秒之后结果不可用。 timeout 可以是int或float。如果未指定 timeout 或 None，则等待时间没有限制。如果调用引发异常，那么当从迭代器检索其值时，将引发异常。当使用 ProcessPoolExecutor 时，此方法将 iterables 分成多个块，它作为单独的任务提交到进程池。这些块的（近似）大小可以通过将 chunksize 设置为正整数来指定。对于非常长的迭代，与默认大小1相比，使用大值 chunksize 可以显着提高性能。使用 ThreadPoolExecutor，chunksize 没有效果。

在 3.5 版更改: 添加了 chunksize 参数。

Executor.map 还有个特性比较有用，那就是这个函数返回结果的顺序于调用开始的顺序是一致的。如果第一个调用称其结果用时10秒，其他调用只用1秒，代码会阻塞10秒，获取map方法返回的生成器产出的第一个结果。

如果不是获取到所有结果再处理，通常会使用 Executor.submit + Executor.as_completed 组合使用的方案。

Executor.submit + Executor.as_completed 这个组合更灵活，因为submit方法能处理不同的可调用对象和参数，而executor.map 只能处理参数不同的同一个可调用对象。此外，传给futures.as_completed 函数的期物集合可以来自不同的 Executor 实例。

future 的异常处理

futures 有三个异常类：

  • exception concurrent.futures.CancelledError  在future取消时引发。

  • exception concurrent.futures.TimeoutError 在future操作超过给定超时时触发。

  • exception concurrent.futures.process.BrokenProcessPool

我们先看一下，future.result() 出现异常的处理情况。代码改动如下：

# 将第一个 CN 改为CN1 也可以是其它任意错误代码

POP20_CC = ('CN1 IN US ID BR PK NG BD RU JP '
            'MX PH VN ET EG DE IR TR CD FR').split()

def get_flag(cc):  # <6>
    url = '{}/{cc}/{cc}.gif'.format(BASE_URL, cc=cc.lower())
    resp = requests.get(url)
    if resp.status_code != 200:  # <1>
        resp.raise_for_status() # 如果不是200 抛出异常
    return resp.content
    

def download_one(cc):
    try:
        image = get_flag(cc)    # 捕获 requests.exceptions.HTTPError
    except requests.exceptions.HTTPError as exc:  #
        # 如果有异常 直接抛出
        raise
    else:
        save_flag(image, cc.lower() + '.gif')
    return cc

现在执行代码，会发现 download_one 中的异常传递到了download_many 中,并且导致抛出了异常，未执行完的其它future 也都中断。

为了能保证其它没有错误的future 可以正常执行，这里我们需要对future.result() 做异常处理。

改动结果如下：

def download_many(cc_list):
    cc_list = cc_list[:5]
    with futures.ThreadPoolExecutor(max_workers=20) as executor:
        to_do_map = {}
        for cc in sorted(cc_list):
            future = executor.submit(download_one, cc)
            to_do_map[future] = cc
            msg = 'Scheduled for {}: {}'
            print(msg.format(cc, future))

        results = []
        for future in futures.as_completed(to_do_map):
            try:
                res = future.result()
            except requests.exceptions.HTTPError as exc:
                # 处理可能出现的异常
                error_msg = '{} result {}'.format(cc, exc)
            else:
                error_msg = ''
            if error_msg:
                cc = to_do_map[future]  # <16>
                print('*** Error for {}: {}'.format(cc, error_msg))
            else:
                msg = '{} result: {!r}'
                print(msg.format(future, res))
                results.append(res)
       return len(results)

这里我们用到了一个对 futures.as_completed 函数特别有用的惯用法：构建一个字典，把各个future映射到其他数据（future运行结束后可能用的）上。这样，虽然 future生成的顺序虽然已经乱了，依然便于使用结果做后续处理。

一篇写完了没有总结总感觉少点什么，所以。

总结

Python 自 0.9.8 版就支持线程了，concurrent.futures 只不过是使用线程的最新方式。

futures.ThreadPoolExecutor 类封装了 threading 模块的组件，使使用线程变得更加方便。

顺便再推荐一下 《流畅的python》，绝对值得一下。

下一篇笔记应该是使用 asyncio 处理并发。

最后，感谢女朋友支持。

恩，也欢迎打赏。

0?wx_fmt=png

czongxiao
关注
Python学习：Python并发编程之Futures
小朱小朱绝不认输的博客
09-17 1480
我们每天在各个网站、各个 App 上获取的新闻信息，很大一部分便是通过并发编程版的爬虫获得。正确合理地使用并发编程，无疑会给我们的程序带来极大的性能提升。今天学习理解、运用 Python 中的并发编程——Futures。 一、区分并发和并行 在操作系统中，并发和并行的概念如下： 并发：在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行，但任一个时刻点上只有一个程序在处理机上运行。简言之，是指系统具有处理多个任务的能力。 并行：当系统有一个以上
Python并发编程之Futures
scu-liu的博客
02-27 240
正确合理地使用并发编程，无疑会给我们的程序带来极大的性能提升。今天这节课，我就带你一起来学习理解、运用 Python 中的并发编程——Futures。 区分并发和并行 在我们学习并发编程时，常常同时听到并发（Concurrency）和并行（Parallelism）这两个术语，这两者经常一起使用，导致很多人以为它们是一个意思，其实不然。 首先你要辨别一个误区，在 Python 中，并发并不是指同一时刻有多个操作（thread、task）同时进行。相反，某个特定的时刻，它只允许有一个操作发生，只不过线程 / 任
python futures 练习
python小菜鸡的博客
04-28 342
闲来无事,看看python futures 多线程这块,确实方便 牛皮 from concurrent.futures import ThreadPoolExecutor import requests import random import pytesseract from PIL import Image url = ["http://www.epicc.com.cn/wap/Cre
Python学习笔记34：使用Futures处理并发
梦幻天空
05-20 576
Python学习笔记34：使用Futures处理并发 概览 Futures模块是Python3中推荐使用的一个并发控制框架，我们可以使用这个模块编写多线程和多进程程序。 在Python中使用Futures模块很简单，只要先安装： pip install futures 然后在Python代码中引用： from concurrent import futures 在介绍如何用Futures实现并发之前，我们先看一个传统的下载程序。 一个传统的下载程序 这个示例程序使用requests摸块进行下载，这个第三
Python并发编程：concurrent.futures与asyncio实战解析
本文主要讨论了Python中用于并发编程的两个关键模块：concurrent.futures和asyncio，以及它们的核心特性和使用方法。 concurrent.futures模块是Python标准库的一部分，自Python3.2开始引入。这个模块提供了一种统一...
Python并发编程：concurrent.futures 模块详解
`concurrent.futures`模块是Python中处理并发执行的核心工具，它简化了多线程和多进程编程。模块的主要目标是为开发者提供一种统一的、高级的接口，以便于异步执行任务，无论底层是基于线程还是进程。 Executor ...
Python并发编程：concurrent.futures模块详解
`concurrent.futures`是Python提供的一种高级接口，用于处理异步执行的未来结果，它简化了多线程和多进程的使用。文中提到了`ThreadPoolExecutor`和`ProcessPoolExecutor`这两个核心类，它们分别用于基于线程和进程...
Python并发concurrent.futures和asyncio实例
12-20
Python并发编程是提升程序效率的关键技术，特别是在处理IO密集型任务时。标准库中的`concurrent.futures`模块提供了一种简洁的接口来管理和执行并发任务，它支持线程池和进程池两种并发模型。 `ThreadPoolExecutor`...
python concurrent.futures 中文文档
04-15
python concurrent.futures最新官网文档中文翻译，自己手动翻译，请勿喷。。。。。
Python 并发编程之Futures
python学习者的博客
09-28 677
区分并发和并行 并发(Concurrency). 由于Python 的解释器并不是线程安全的，为了解决由此带来的 race condition 等问题，Python 便引入了全局解释器锁，也就是同一时刻，只允许一个线程执行。当然，在执行 I/O 操作时，如果一个线程被 block 了，全局解释器锁便会被释放，从而让另一个线程能够继续执行。所以在Python中，并发并不是指同一时刻有多个操作(thr...
Python 并发编程 Futures
分享既学习
07-27 464
本篇文章介绍了如何使用 Futures 创建线程池和进程池，并提供了两个 case，在实验过程中发现，因为 GIL 的原因 Python 的线程池并不适合 CPU 密集型的应用，此时就需要考虑使用多进程的方式，或者将核心代码使用 C++ 编写通过 Python 调用，从而绕过 GIL。虽然有 GIL 用户依然要考虑线程安全的问题，因为 GIL 只是方便 Python 解释器的编写人员，而不是 Python 程序的编写人员。程序每次执行的结果可能都不相同，结果都不为 0，此时就需要使用线程锁来规避此类问题。
Python并发之futures
daotian
03-23 178
python并发与并行详解： import requests import time import concurrent.futures import threading # 单线程版下载 def download_one(url): resp = requests.get(url) print("read {} from {}".format(len(resp.content), url)) def download_all(sites): for site in sites: d
Python并发编程Futures
rs勿忘初心的博客
11-14 910
无论对于哪门语言，并发编程都是一项很常用很重要的技巧。正确合理地使用并发编程，无疑会给程序带来极大的性能提升。 1.并行和并发 并发（Concurrency）和并行（Parallelism）这两个术语经常一起使用，导致很多人以为它们是一个意思，其实不然。 在 Python 中，并发并不是指同一时刻有多个操作（thread、task）同时进行。相反，某个特定的时刻，它只允许有一个操作发生，只不过线程 / 任务之间会互相切换，直到完成。 我们来看下面这张图，图中出现了 thread 和 task 两
【Python核心】并发编程之Futures
sysu_lluozh
07-24 273
无论对于哪门语言，并发编程都是一项很常用很重要的技巧 正确合理地使用并发编程，无疑会让程序带来极大的性能提升。接下来学习理解、运用Python中的并发编程——Futures 一、区分并发和并行 在学习并发编程时，常常同时听到并发(Concurrency)和并行(Parallelism)这两个术语，这两者经常一起使用导致很多人以为它们是一个意思，其实不然 1.1 理解误区 首先辨别一个误区，在Python中并发并不是指同一时刻有多个操作(thread、task)同时进行。相反，某个特定的时刻它只允许有一个操作
21 | Python并发编程之Futures
最新发布
qq_37756660的博客
11-24 1177
Python 中的 Futures 模块，位于 concurrent.futures 和 asyncio 中，它们都表示带有延迟的操作。Futures 会将处于等待状态的操作包裹起来放到队列中，这些操作的状态随时可以查询，当然，它们的结果或是异常，也能够在操作完成后被获取。通常来说，作为用户，我们不用考虑如何去创建 Futures，这些 Futures 底层都会帮我们处理好。我们要做的，实际上是去 schedule 这些 Futures 的执行。
python 的__future__ 使用
Katios
07-16 5371
这个库通过名字我们可以猜到是个特性有关的库。 通常特性又是和版本联系在一起的。没错这个库就是为了让我们兼容python2 和python3 的。 由于Python是由社区推动的开源并且免费的开发语言，不受商业公司控制，因此，Python的改进往往比较激进，不兼容的情况时有发生。Python为了确保你能顺利过渡到新版本，特别提供了__future__模块，让你在旧的版本中试验新版本的一些特性。
Python核心丨并发编程之Futures
m0_45198298的博客
06-24 313
Futures 区分并发和并行 并发(Concurrency) 并行(Parallelism) 在Python中，并发并不是指同一时刻有多个操作（thread、task）同时进行。相反某个特定的时刻，它只允许有一个操作发生，只不过线程/任务之间互相切换，直到完成。 thread和task分别对应Python中并发的两种形式threading和asyncio。 threading，操作系统知道每个线程的所有信息，因此它会做主在适当的时候做线程切换。 asyncio，主线程想要切换任务时，必须得到此任务可以
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值