Python并发编程Futures

最新推荐文章于 2023-11-24 16:55:48 发布

rs勿忘初心

最新推荐文章于 2023-11-24 16:55:48 发布

阅读量812

点赞数 1

分类专栏： # Python技术学习文章标签： python 并发编程 Futures 并发并行

本文链接：https://blog.csdn.net/sinat_33718563/article/details/121320200

版权

Python技术学习专栏收录该内容

88 篇文章 10 订阅

订阅专栏

2.3 为什么多线程每次只能有一个线程执行？

2.4 在Futures，如何判断任务是否完成以及获取结果？

无论对于哪门语言，并发编程都是一项很常用很重要的技巧。正确合理地使用并发编程，无疑会给程序带来极大的性能提升。

1.并行和并发

并发（Concurrency）和并行（Parallelism）这两个术语经常一起使用，导致很多人以为它们是一个意思，其实不然。

在 Python 中，并发并不是指同一时刻有多个操作（thread、task）同时进行。相反，某个特定的时刻，它只允许有一个操作发生，只不过线程 / 任务之间会互相切换，直到完成。

我们来看下面这张图，图中出现了 thread 和 task 两种切换顺序的不同方式，分别对应 Python 中并发的两种形式——threading 和 asyncio。

对于 threading，操作系统知道每个线程的所有信息，因此它会做主在适当的时候做线程切换。很显然，这样的好处是代码容易书写，因为程序员不需要做任何切换操作的处理；但是切换线程的操作，也有可能出现在一个语句执行的过程中（比如 x += 1），这样就容易出现 race condition 的情况。

而对于 asyncio，主程序想要切换任务时，必须得到此任务可以被切换的通知，这样一来也就可以避免刚刚提到的 race condition 的情况。

至于所谓的并行，指的才是同一时刻、同时发生。Python 中的 multi-processing 便是这个意思，对于 multi-processing，你可以简单地这么理解：比如你的电脑是 6 核处理器，那么在运行程序时，就可以强制 Python 开 6 个进程，同时执行，以加快运行速度，它的原理示意图如下：

简单对比并发和并行：

并发通常应用于 I/O 操作频繁的场景，比如你要从网站上下载多个文件，I/O 操作的时间可能会比 CPU 运行处理的时间长得多。
而并行则更多应用于 CPU heavy 的场景，比如 MapReduce 中的并行计算，为了加快运行速度，一般会用多台机器、多个处理器来完成。

2.并发编程之 Futures

2.1 单线程与多线程性能比较

首先通过一个具体的实例，从代码的角度来理解并发编程中的 Futures，并进一步来比较其与单线程的性能区别。假设我们有一个任务，是下载一些网站的内容并打印，如果用单线程的方式，它的基本代码实现如下：

流程比较简单：

先是遍历存储网站的列表；
然后对当前网站执行下载操作；
等到当前操作完成后，再对下一个网站进行同样的操作，一直到结束。

import requests
import time

def download_one(url):
    resp = requests.get(url)
    print('Read {} from {}'.format(len(resp.content), url))
    
def download_all(sites):
    for site in sites:
        download_one(site)

def main():
    sites = [
        'https://www.baidu.com/s?wd=Portal:Arts',
        'https://www.baidu.com/s?wd=Portal:History',
        'https://www.baidu.com/s?wd=Portal:Society',
        'https://www.baidu.com/s?wd=Portal:Biography',
        'https://www.baidu.com/s?wd=Portal:Mathematics',
        'https://www.baidu.com/s?wd=Portal:Technology',
        'https://www.baidu.com/s?wd=Portal:Geography',
        'https://www.baidu.com/s?wd=Portal:Science',
        'https://www.baidu.com/s?wd=Computer_science',
        'https://www.baidu.com/s?wd=Python_(programming_language)',
        'https://www.baidu.com/s?wd=Java_(programming_language)',
        'https://www.baidu.com/s?wd=PHP',
        'https://www.baidu.com/s?wd=Node.js',
        'https://www.baidu.com/s?wd=The_C_Programming_Language',
        'https://www.baidu.com/s?wd=Go_(programming_language)'
    ]
    start_time = time.perf_counter()
    download_all(sites)
    end_time = time.perf_counter()
    print('Download {} sites in {} seconds'.format(len(sites), end_time - start_time))
    
if __name__ == '__main__':
    main()

运行结果：

Read 227 from https://www.baidu.com/s?wd=Portal:Arts
Read 227 from https://www.baidu.com/s?wd=Portal:History
Read 227 from https://www.baidu.com/s?wd=Portal:Society
Read 227 from https://www.baidu.com/s?wd=Portal:Biography
Read 227 from https://www.baidu.com/s?wd=Portal:Mathematics
Read 227 from https://www.baidu.com/s?wd=Portal:Technology
Read 227 from https://www.baidu.com/s?wd=Portal:Geography
Read 227 from https://www.baidu.com/s?wd=Portal:Science
Read 227 from https://www.baidu.com/s?wd=Computer_science
Read 227 from https://www.baidu.com/s?wd=Python_(programming_language)
Read 227 from https://www.baidu.com/s?wd=Java_(programming_language)
Read 227 from https://www.baidu.com/s?wd=PHP
Read 227 from https://www.baidu.com/s?wd=Node.js
Read 227 from https://www.baidu.com/s?wd=The_C_Programming_Language
Read 227 from https://www.baidu.com/s?wd=Go_(programming_language)
Download 15 sites in 1.053478813 seconds

我们可以看到总共耗时约 1s+。单线程的优点是简单明了，但是明显效率低下，因为上述程序的绝大多数时间，都浪费在了 I/O 等待上。程序每次对一个网站执行下载操作，都必须等到前一个网站下载完成后才能开始。如果放在实际生产环境中，我们需要下载的网站数量至少是以万为单位的，不难想象，这种方案根本行不通。

接着我们再来看看多线程版本的代码实现：

import concurrent.futures
import requests
import threading
import time

def download_one(url):
    resp = requests.get(url)
    print('Read {} from {}'.format(len(resp.content), url))


def download_all(sites):
    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
        executor.map(download_one, sites)

def main():
    sites = [
        'https://www.baidu.com/s?wd=Portal:Arts',
        'https://www.baidu.com/s?wd=Portal:History',
        'https://www.baidu.com/s?wd=Portal:Society',
        'https://www.baidu.com/s?wd=Portal:Biography',
        'https://www.baidu.com/s?wd=Portal:Mathematics',
        'https://www.baidu.com/s?wd=Portal:Technology',
        'https://www.baidu.com/s?wd=Portal:Geography',
        'https://www.baidu.com/s?wd=Portal:Science',
        'https://www.baidu.com/s?wd=Computer_science',
        'https://www.baidu.com/s?wd=Python_(programming_language)',
        'https://www.baidu.com/s?wd=Java_(programming_language)',
        'https://www.baidu.com/s?wd=PHP',
        'https://www.baidu.com/s?wd=Node.js',
        'https://www.baidu.com/s?wd=The_C_Programming_Language',
        'https://www.baidu.com/s?wd=Go_(programming_language)'
    ]
    start_time = time.perf_counter()
    download_all(sites)
    end_time = time.perf_counter()
    print('Download {} sites in {} seconds'.format(len(sites), end_time - start_time))

if __name__ == '__main__':
    main()

运行结果：

Read 227 from https://www.baidu.com/s?wd=Portal:History
Read 227 from https://www.baidu.com/s?wd=Portal:Mathematics
Read 227 from https://www.baidu.com/s?wd=Portal:Society
Read 227 from https://www.baidu.com/s?wd=Portal:Arts
Read 227 from https://www.baidu.com/s?wd=Portal:Biography
Read 227 from https://www.baidu.com/s?wd=Computer_science
Read 227 from https://www.baidu.com/s?wd=Python_(programming_language)
Read 227 from https://www.baidu.com/s?wd=Portal:Science
Read 227 from https://www.baidu.com/s?wd=Portal:Geography
Read 227 from https://www.baidu.com/s?wd=Portal:Technology
Read 227 from https://www.baidu.com/s?wd=Java_(programming_language)
Read 227 from https://www.baidu.com/s?wd=PHP
Read 227 from https://www.baidu.com/s?wd=Node.js
Read 227 from https://www.baidu.com/s?wd=The_C_Programming_Language
Read 227 from https://www.baidu.com/s?wd=Go_(programming_language)
Download 15 sites in 0.25518121699999996 seconds

非常明显，总耗时是 0.25s 左右，效率一下子提升了 4 倍多。具体来看这段代码，它是多线程版本和单线程版的主要区别所在：

with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
     executor.map(download_one, sites)

这里我们创建了一个线程池，总共有 5 个线程可以分配使用。executor.map() 与前面所讲的 Python 内置的 map() 函数类似，表示对 sites 中的每一个元素，并发地调用函数 download_one()。

顺便提一下，在 download_one() 函数中，我们使用的 requests.get() 方法是线程安全的（thread-safe），因此在多线程的环境下，它也可以安全使用，并不会出现 race condition 的情况。

另外，虽然线程的数量可以自己定义，但是线程数并不是越多越好，因为线程的创建、维护和删除也会有一定的开销。所以如果你设置的很大，反而可能会导致速度变慢。我们往往需要根据实际的需求做一些测试，来寻找最优的线程数量。

当然，我们也可以用并行的方式去提高程序运行效率。你只需要在 download_all() 函数中，做出下面的变化即可：

with futures.ThreadPoolExecutor(workers) as executor
=>
with futures.ProcessPoolExecutor() as executor:

在需要修改的这部分代码中，函数 ProcessPoolExecutor() 表示创建进程池，使用多个进程并行的执行程序。不过，这里我们通常省略参数 workers，因为系统会自动返回 CPU 的数量作为可以调用的进程数。

并行的方式一般用在 CPU heavy 的场景中，因为对于 I/O heavy 的操作，多数时间都会用于等待，相比于多线程，使用多进程并不会提升效率。反而很多时候，因为 CPU 数量的限制，会导致其执行效率不如多线程版本。

2.2 到底什么是 Futures ？

Python 中的 Futures 模块，位于 concurrent.futures 和 asyncio 中，它们都表示带有延迟的操作。Futures 会将处于等待状态的操作包裹起来放到队列中，这些操作的状态随时可以查询，当然，它们的结果或是异常，也能够在操作完成后被获取。

通常来说，作为用户，我们不用考虑如何去创建 Futures，这些 Futures 底层都会帮我们处理好。我们要做的，实际上是去 schedule 这些 Futures 的执行。

比如，Futures 中的 Executor 类，当我们执行 executor.submit(func) 时，它便会安排里面的 func() 函数执行，并返回创建好的 future 实例，以便你之后查询调用。

这里再介绍一些常用的函数。Futures 中的方法 done()，表示相对应的操作是否完成——True 表示完成，False 表示没有完成。不过，要注意，done() 是 non-blocking 的，会立即返回结果。相对应的 add_done_callback(fn)，则表示 Futures 完成后，相对应的参数函数 fn，会被通知并执行调用。

Futures 中还有一个重要的函数 result()，它表示当 future 完成后，返回其对应的结果或异常。而 as_completed(fs)，则是针对给定的 future 迭代器 fs，在其完成后，返回完成后的迭代器。

所以，上述例子也可以写成下面的形式：


import concurrent.futures
import requests
import time

def download_one(url):
    resp = requests.get(url)
    print('Read {} from {}'.format(len(resp.content), url))

def download_all(sites):
    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
        to_do = []
        for site in sites:
            future = executor.submit(download_one, site)
            to_do.append(future)
            
        for future in concurrent.futures.as_completed(to_do):
            future.result()
def main():
    sites = [
        'https://www.baidu.com/s?wd=Portal:Arts',
        'https://www.baidu.com/s?wd=Portal:History',
        'https://www.baidu.com/s?wd=Portal:Society',
        'https://www.baidu.com/s?wd=Portal:Biography',
        'https://www.baidu.com/s?wd=Portal:Mathematics',
        'https://www.baidu.com/s?wd=Portal:Technology',
        'https://www.baidu.com/s?wd=Portal:Geography',
        'https://www.baidu.com/s?wd=Portal:Science',
        'https://www.baidu.com/s?wd=Computer_science',
        'https://www.baidu.com/s?wd=Python_(programming_language)',
        'https://www.baidu.com/s?wd=Java_(programming_language)',
        'https://www.baidu.com/s?wd=PHP',
        'https://www.baidu.com/s?wd=Node.js',
        'https://www.baidu.com/s?wd=The_C_Programming_Language',
        'https://www.baidu.com/s?wd=Go_(programming_language)'
    ]
    start_time = time.perf_counter()
    download_all(sites)
    end_time = time.perf_counter()
    print('Download {} sites in {} seconds'.format(len(sites), end_time - start_time))

if __name__ == '__main__':
    main()

运行结果：

Read 227 from https://www.baidu.com/s?wd=Portal:History
Read 227 from https://www.baidu.com/s?wd=Portal:Arts
Read 227 from https://www.baidu.com/s?wd=Portal:Society
Read 227 from https://www.baidu.com/s?wd=Portal:Biography
Read 227 from https://www.baidu.com/s?wd=Portal:Mathematics
Read 227 from https://www.baidu.com/s?wd=Python_(programming_language)
Read 227 from https://www.baidu.com/s?wd=Portal:Geography
Read 227 from https://www.baidu.com/s?wd=Portal:Technology
Read 227 from https://www.baidu.com/s?wd=Portal:Science
Read 227 from https://www.baidu.com/s?wd=Computer_science
Read 227 from https://www.baidu.com/s?wd=Go_(programming_language)
Read 227 from https://www.baidu.com/s?wd=PHP
Read 227 from https://www.baidu.com/s?wd=Node.js
Read 227 from https://www.baidu.com/s?wd=The_C_Programming_Language
Read 227 from https://www.baidu.com/s?wd=Java_(programming_language)
Download 15 sites in 0.6074131429999999 seconds

我们首先调用 executor.submit()，将下载每一个网站的内容都放进 future 队列 to_do，等待执行。然后是 as_completed() 函数，在 future 完成后，便输出结果。不过，这里要注意，future 列表中每个 future 完成的顺序，和它在列表中的顺序并不一定完全一致。到底哪个先完成、哪个后完成，取决于系统的调度和每个 future 的执行时间。

2.3 为什么多线程每次只能有一个线程执行？

同一时刻，Python 主程序只允许有一个线程执行，所以 Python 的并发，是通过多线程的切换完成的。你可能会疑惑这到底是为什么呢？

事实上，Python 的解释器并不是线程安全的，为了解决由此带来的 race condition 等问题，Python 便引入了全局解释器锁，也就是同一时刻，只允许一个线程执行。当然，在执行 I/O 操作时，如果一个线程被 block 了，全局解释器锁便会被释放，从而让另一个线程能够继续执行。

2.4 在Futures，如何判断任务是否完成以及获取结果？

这里补充2个demo，推荐使用第二种，因为第一种方式是显示等待后拿到结果，如果不知道任务运行多久，这样会比较笨（额，我刚开始就是这样弄的），第二种方法就要优雅很多了，通过future.done()判断线程执行状态是否结束和future.result()拿到函数的返回结果，直接看代码：

方法1：

import time
from logzero import logger
from concurrent.futures import ThreadPoolExecutor  # 线程池模块

# 全局变量，线程池临时结果存储
_thread_pool_executor_result = []


def demo1():
    logger.info("start demo1 ...")
    time.sleep(5)
    logger.info("end demo1 ...")

    return ["demo1 result"]


def callback(data):
    """
    # 线程池运行回调函数
    :param data:
    :return:
    """
    # 修改全局变量，需要使用关键字global
    global _thread_pool_executor_result
    _thread_pool_executor_result = data.result()


def main():
    pool = ThreadPoolExecutor(1)
    logger.info("debug 1")
    # 执行完线程后，跟一个函数回调函数
    pool.submit(demo1, ).add_done_callback(callback)
    logger.info("debug 2")
    logger.info(_thread_pool_executor_result)
    logger.info("debug 3")
    time.sleep(6)
    logger.info(_thread_pool_executor_result)

if __name__ == '__main__':
    # 主函数
    main()

运行结果：

[I 211115 09:16:26 demo222:30] debug 1
[I 211115 09:16:26 demo222:10] start demo1 ...
[I 211115 09:16:26 demo222:33] debug 2
[I 211115 09:16:26 demo222:34] []
[I 211115 09:16:26 demo222:35] debug 3
[I 211115 09:16:31 demo222:12] end demo1 ...
[I 211115 09:16:32 demo222:37] ['demo1 result']

方法2:

import time
from logzero import logger
from concurrent.futures import ThreadPoolExecutor  # 线程池模块

# 全局变量，线程池临时结果存储
_thread_pool_executor_result = []


def demo1():
    logger.info("start demo1 ...")
    time.sleep(5)
    logger.info("end demo1 ...")

    return ["demo1 result"]


def callback(data):
    """
    # 线程池运行回调函数
    :param data:
    :return:
    """
    # 修改全局变量，需要使用关键字global
    global _thread_pool_executor_result
    _thread_pool_executor_result = data.result()


def main():
    pool = ThreadPoolExecutor(1)
    logger.info("debug 1")

    # Futures 中的方法 done()，表示相对应的操作是否完成——True表示完成，False 表示没有完成
    future = pool.submit(demo1,)
    logger.info("debug 2")
    # Ps：这里可以加个超时等待机制，不然可能死循环
    while True:
        if future.done():
            logger.info("future job done.")
            logger.info(future.result())
            break
        else:
            logger.info("future job not done, will sleep 1s.")
            time.sleep(1)


if __name__ == '__main__':
    # 主函数
    main()

运行结果：

[I 211115 09:15:15 demo222:30] debug 1
[I 211115 09:15:15 demo222:10] start demo1 ...
[I 211115 09:15:15 demo222:41] debug 2
[I 211115 09:15:15 demo222:49] future job not done, will sleep 1s.
[I 211115 09:15:16 demo222:49] future job not done, will sleep 1s.
[I 211115 09:15:17 demo222:49] future job not done, will sleep 1s.
[I 211115 09:15:18 demo222:49] future job not done, will sleep 1s.
[I 211115 09:15:19 demo222:49] future job not done, will sleep 1s.
[I 211115 09:15:20 demo222:12] end demo1 ...
[I 211115 09:15:20 demo222:45] future job done.
[I 211115 09:15:20 demo222:46] ['demo1 result']

rs勿忘初心

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Python并发编程Futures

无论对于哪门语言，并发编程都是一项很常用很重要的技巧。正确合理地使用并发编程，无疑会给程序带来极大的性能提升。1.并行和并发并发（Concurrency）和并行（Parallelism）这两个术语经常一起使用，导致很多人以为它们是一个意思，其实不然。在 Python 中，并发并不是指同一时刻有多个操作（thread、task）同时进行。相反，某个特定的时刻，它只允许有一个操作发生，只不过线程 / 任务之间会互相切换，直到完成。我们来看下面这张图，图中出现了 thread 和 task 两
复制链接

扫一扫