Python 之 concurrent.futures 使用

已于 2024-12-13 16:17:38 修改
阅读量727 收藏 7
点赞数 5
CC 4.0 BY-SA版权
分类专栏： Python 文章标签： python
于 2024-12-13 12:14:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TomorrowAndTuture/article/details/144445268

之前多线程用 threading 的时候比较多，最近看看 concurrent.futures 实现多线程多进程的方法。

ThreadPoolExecutor

ThreadPoolExecutor 适合对于I/O密集的任务，比如如网络请求、文件操作等。

多线程中 print 打印换行有点乱，这是因为 print 打印 value 和 end 换行符的操作不是原子的，多线程的时候可能中间还会穿插其他打印操作。所以我们自己手动在 value 加上换行符就可以了。

不阻塞

import datetime
import time
from concurrent import futures


def run(n):
    # print(f"{datetime.datetime.now()} 线程 Thread-{n} 开始执行")
    time.sleep(3)
    print(f"{datetime.datetime.now()} 线程 Thread-{n} 执行结束\n", end='')


if __name__ == '__main__':
    print(f"{datetime.datetime.now()}  主线程开始执行\n", end='')
    all_task = []
    executor = futures.ThreadPoolExecutor(max_workers=3)
    for i in range(1, 8):
        task = executor.submit(run, i)
        all_task.append(task)
    print(f"{datetime.datetime.now()}  主线程结束执行\n", end='')

2024-12-13 11:26:33.465840  主线程开始执行
2024-12-13 11:26:33.469839  主线程结束执行
2024-12-13 11:26:36.469357 线程 Thread-1 执行结束
2024-12-13 11:26:36.470359 线程 Thread-3 执行结束
2024-12-13 11:26:36.470359 线程 Thread-2 执行结束
2024-12-13 11:26:39.469776 线程 Thread-4 执行结束
2024-12-13 11:26:39.470677 线程 Thread-5 执行结束
2024-12-13 11:26:39.471319 线程 Thread-6 执行结束
2024-12-13 11:26:42.470184 线程 Thread-7 执行结束

阻塞

使用 with ThreadPoolExecutor 时，看源码可知 executor.__exit__ 方法会调用 executor.shutdown(wait=True) 方法，它会在所有线程都执行完毕前阻塞线程。

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.shutdown(wait=True)
        return False
import datetime
import time
from concurrent import futures


def run(n):
    # print(f"{datetime.datetime.now()} 线程 Thread-{n} 开始执行")
    time.sleep(3)
    print(f"{datetime.datetime.now()} 线程 Thread-{n} 执行结束\n", end='')


if __name__ == '__main__':
    print(f"{datetime.datetime.now()}  主线程开始执行\n", end='')
    with futures.ThreadPoolExecutor(max_workers=3) as executor:
        all_task = executor.map(run, range(1, 8))
    print(f"{datetime.datetime.now()}  主线程结束执行\n", end='')

2024-12-13 11:20:14.092288  主线程开始执行
2024-12-13 11:20:17.095038 线程 Thread-1 执行结束
2024-12-13 11:20:17.096037 线程 Thread-2 执行结束
2024-12-13 11:20:17.096227 线程 Thread-3 执行结束
2024-12-13 11:20:20.095460 线程 Thread-4 执行结束
2024-12-13 11:20:20.096544 线程 Thread-5 执行结束
2024-12-13 11:20:20.096544 线程 Thread-6 执行结束
2024-12-13 11:20:23.095876 线程 Thread-7 执行结束
2024-12-13 11:20:23.095876  主线程结束执行

当然，我们也可以不用 with ，然后手动调用 wait 方法按指定条件进行阻塞也是一样。

import datetime
import time
from concurrent import futures


def run(n):
    # print(f"{datetime.datetime.now()} 线程 Thread-{n} 开始执行")
    time.sleep(3)
    print(f"{datetime.datetime.now()} 线程 Thread-{n} 执行结束\n", end='')


if __name__ == '__main__':
    print(f"{datetime.datetime.now()}  主线程开始执行\n", end='')
    all_task = []
    executor = futures.ThreadPoolExecutor(max_workers=3)
    for i in range(1, 8):
        task = executor.submit(run, i)
        all_task.append(task)
    futures.wait(all_task, return_when=futures.FIRST_COMPLETED)
    print(f"{datetime.datetime.now()}  主线程结束执行\n", end='')

2024-12-13 11:35:50.043853  主线程开始执行
2024-12-13 11:35:53.047452 线程 Thread-1 执行结束
2024-12-13 11:35:53.047452  主线程结束执行
2024-12-13 11:35:53.048664 线程 Thread-3 执行结束
2024-12-13 11:35:53.048664 线程 Thread-2 执行结束
2024-12-13 11:35:56.048256 线程 Thread-4 执行结束
2024-12-13 11:35:56.049267 线程 Thread-6 执行结束
2024-12-13 11:35:56.049267 线程 Thread-5 执行结束
2024-12-13 11:35:59.048616 线程 Thread-7 执行结束

as_completed

futures.as_completed 在并发执行多个任务的情况下。它可以帮助我们在任务完成时立即处理结果，而不需要等待所有任务都完成。显然，此时再用 futures.wait 的话显然就不应该了。

我们甚至可以依赖这个特性做一个任务处理的实时进度条：

import datetime
import random
import time
import sys
from concurrent import futures


def run(n):
    print(f"{datetime.datetime.now()} 任务 Task-{n} 开始执行\n", end='')
    time.sleep(random.randint(2, 10))
    return f"Task-{n}"


if __name__ == '__main__':
    print(f"{datetime.datetime.now()} 主任务开始执行\n", end='')
    all_task = []
    executor = futures.ThreadPoolExecutor(max_workers=7)
    for i in range(1, 8):
        task = executor.submit(run, i)
        all_task.append(task)
    # futures.wait(all_task, return_when=futures.ALL_COMPLETED)
    future_iter = futures.as_completed(all_task)
    total_count = len(all_task)
    i = 0
    for future in future_iter:
        i += 1
        percent = "{:.0%}".format(i / total_count)
        length = int(percent.replace("%", ""))
        task_name = future.result()
        s = "\r处理进度 %s>%3s" % ("=" * length, percent)  # \r表示回车但是不换行，利用这个原理进行百分比的刷新
        sys.stdout.write(s)  # 向标准输出终端写内容
        sys.stdout.flush()  # 立即将缓存的内容刷新到标准输出
        # print(f"{datetime.datetime.now()} 任务 {task_name} 执行结束\n", end='')
    print()
    print(f"{datetime.datetime.now()} 主任务结束执行\n", end='')

2024-12-13 15:58:32.919201 主任务开始执行
2024-12-13 15:58:32.922109 任务 Task-1 开始执行
2024-12-13 15:58:32.922109 任务 Task-2 开始执行
2024-12-13 15:58:32.923108 任务 Task-3 开始执行
2024-12-13 15:58:32.923108 任务 Task-4 开始执行
2024-12-13 15:58:32.923108 任务 Task-5 开始执行
2024-12-13 15:58:32.924107 任务 Task-6 开始执行
2024-12-13 15:58:32.924107 任务 Task-7 开始执行
处理进度 ====================================================================================================>100%
2024-12-13 15:58:41.924904 主任务结束执行

ProcessPoolExecutor

ProcessPoolExecutor 使用的是多进程，而不是多线程，因此它更适合处理 CPU 密集型任务。至于提供的方法方面，和 ThreadPoolExecutor 基本上是保持一致的。

import datetime
import time
from concurrent import futures


def run(n):
    # print(f"{datetime.datetime.now()} 任务 Thread-{n} 开始执行")
    time.sleep(3)
    print(f"{datetime.datetime.now()} 任务 Task-{n} 执行结束\n", end='')
    return n


if __name__ == '__main__':
    print(f"{datetime.datetime.now()} 主任务开始执行\n", end='')
    all_task = []
    executor = futures.ProcessPoolExecutor(max_workers=3)
    for i in range(1, 8):
        task = executor.submit(run, i)
        all_task.append(task)
    futures.wait(all_task, return_when=futures.ALL_COMPLETED)
    print(f"{datetime.datetime.now()} 主任务结束执行\n", end='')

2024-12-13 12:12:18.384247 主任务开始执行
2024-12-13 12:12:21.493002 任务 Task-1 执行结束
2024-12-13 12:12:21.494054 任务 Task-2 执行结束
2024-12-13 12:12:21.494054 任务 Task-3 执行结束
2024-12-13 12:12:24.493574 任务 Task-4 执行结束
2024-12-13 12:12:24.495136 任务 Task-6 执行结束
2024-12-13 12:12:24.495136 任务 Task-5 执行结束
2024-12-13 12:12:27.494583 任务 Task-7 执行结束
2024-12-13 12:12:27.494583 主任务结束执行

与 ThreadPoolExecutor 的多线程相比，ProcessPoolExecutor 可以做到多进程真正并行（不是并发），从而来绕过 全局解释器锁的限制。但是进程池切换进程之间存在更大的消耗，因此在可以使用线程池时就尽量使用线程池。 

并发和并行的联系与区别可参考：并行和并发有什么区别_并发和并行的区别-CSDN博客 ，《流畅的Python》中也有更简单的定义。并发是指一次处理多件事，并行是指一次做多件事，相对而言，并行更加强调同时。

深入理解 Python 的 concurrent.futures 模块
猫敷雪
10-14 344
是 Python 标准库中的一个模块，旨在简化并发编程。它提供了一种高层次的接口，用于异步执行任务，并支持线程池和进程池。这使得开发者能够轻松地管理并发执行的任务，从而提高程序的性能。
Python的concurrent.futures ：ThreadPoolExecutor（线程池）和 ProcessPoolExecutor（进程池）
qiy_icbc的博客
09-05 1717
示了如何使用 ThreadPoolExecutor 和 ProcessPoolExecutor 来并行执行多个任务。ThreadPoolExecutor 适用于I/O密集型任务（如网络请求、文件读写等），而 ProcessPoolExecutor 更适合CPU密集型任务。然而，对于网络请求，由于GIL的存在对线程的影响较小，并且进程间通信的开销通常比线程间通信要大，因此在实际应用中，ThreadPoolExecutor 可能是更合适的选择。
Python concurrent.futures模块的ProcessPoolExecutor, ThreadPoolExecutor类介绍
最新发布
qq_27390023的博客
04-19 462
concurrent.futures 模块中的 ProcessPoolExecutor 和 ThreadPoolExecutor 类是用于实现并发编程的两种主要工具，它们分别基于进程和线程来执行任务。
concurrent.futures模块使用
chang995196962的博客
09-03 2685
一、概念总结 1-1 池：控制进程数或线程数的概念。 1-2 同步&异步调用：提交任务的两种方式 1-3 阻塞&非阻塞：程序的运行状态 二、concurrent.futures 模块实现‘池’ 2-0concurrent.futures基本总结 2-0-1 基本方法（进程池和线程池都适用） 2-1 进程池 2-1-1 进程池的两种任务提交方式 2-1-2 进程池的同步调用方式 2-1-3 进程池的异步调用方式 2-1-4进程池,异步调用+回调函数：解决耦合，速度慢 ..
concurrent.futures
坑底Z蛙
07-29 734
  需要下载的图片列表为，是妹子 图中的一个页面(http://www.meizitu.com/a/5593.html)的所有图片，列表是用python爬的。 urlList = ['http://mm.chinasareview.com/wp-content/uploads/2018a/01/01/01.jpg', 'http://mm.chinasareview.com/wp-conte...
python 线程池 concurrent.futures ThreadPoolExecutor
marc_chen的博客
07-04 2204
python 线程池 concurrent.futures ThreadPoolExecutor
《Python实战进阶》No44: 并发框架：concurrent.futures 的使用（下）
yweng18的博客
04-10 1561
`concurrent.futures` 是 Python 标准库中简化并发编程的核心工具，通过 **线程池（ThreadPoolExecutor）** 和 **进程池（ProcessPoolExecutor）** 实现高效的并发任务调度。本篇结合实战案例，在上集中，我们结合 Future 对象和回调机制，通过两个实战案例”API 请求并发处理”，“矩阵运算并行化“展示如何通过上下文管理器优雅地管理资源。在本文，我们将巩固所学知识，演示如何通过 `submit()`、`map()` 等方法并行化处理 I/O
Python并发concurrent.futures和asyncio实例
12-20
Python并发编程是提升程序效率的关键技术，特别是在处理IO密集型任务时...总的来说，`concurrent.futures`和`asyncio`为Python程序员提供了强大且灵活的并发解决方案，可以根据具体场景选择合适的工具来提高代码性能。
浅谈Python库之concurrent.futures
a876106354的博客
12-30 777
是 Python 标准库中的一个模块，用于实现异步编程，它提供了一个高级接口来处理异步执行的可调用对象（如函数）。这个模块主要用于简化线程和进程的并发编程，使得开发者可以更方便地利用多核处理器的优势来提高程序的性能。
concurrent.futures多线程使用
qq_37347802的博客
07-22 283
1.ThreadPoolExecutor多线程 from flask import Flask,request,json app=Flask(__name__) @app.route('/test',methods=['GET', 'POST']) def test(): a = [1, 2, 3, 4, 5, 6, 7, 8] a= request.json.get('a') executor = Cfutures.ThreadPoolExecutor(max_workers=
concurrent.futures模块ThreadPoolExecutor、ProcessPoolExecutor讲解及使用实例
weixin_43587784的博客
02-23 6512
concurrent.futures模块ThreadPoolExecutor、ProcessPoolExecutor讲解及使用实例
python concurrent.futures ThreadPoolExecutor
sinat_34194779的博客
11-16 265
【代码】python concurrent.futures ThreadPoolExecutor。
concurrent.futures模块中ThreadPoolExecutor用法
NLP工程化
07-01 815
ThreadPoolExecutor 是 Python 的 concurrent.futures 模块中的一个类，用于并发执行多个任务。通过使用线程池，它允许你将任务分配给池中的线程来执行，而不是每次需要执行任务时都创建新线程。这种方式可以显著提高性能和效率，特别是在执行大量短暂任务时，因为它减少了线程创建和销毁的开销。
[python]线程池concurrent.futures ThreadPoolExecutor
qq_38065133的博客
09-20 1628
from concurrent.futures import ThreadPoolExecutor, as_completed, wait, FIRST_COMPLETED from concurrent.futures import Future from multiprocessing import Pool #未来对象，task的返回容器 #线程池， 为什么要线程池 设置数量线程与se...
第17章：使用 concurrent.futures 模块处理并发-ThreadPoolExecutor 多线程并发和 Future 介绍
waitan2018的博客
09-11 3016
本章主要讨论 Python 3.2 引入的 concurrent.futures 模块。这一章还会介绍“Future”的概念，Future 指一种对象，表示异步执行的操作。这个概念的作用很大，是 concurrent.futures 模块和 asyncio 包的基础。 17.1使用 concurrent.futures 模块并发处理下载任务 为了高效处理网络 I/O，需要使用并发，因为网络有很高的延迟，所以为了不浪费 CPU 周期去等待，最好在收到网络响应之前做些其他的事。为了说明这一点，我们通过代码.
concurrent.futures.ThreadPoolExecutor并发库详解
漫步量化
08-15 9058
concurrent.futures Python3.2带来的新版功能。是Python并发执行的标准库。 这个模块具有线程池和进程池、管理并行编程任务、处理非确定性的执行流程、进程/线程同步等功能。 concurrent.futures 是两个文件放在一起作为这个模块，因为concurrent文件夹下只有futures这个文件夹，而futures下有两个主要文件thread.py和proces...
concurrent.futures中ThreadPoolExecutor使用
s_crawler的博客
08-01 2101
# -*- coding: utf-8 -*- import time from concurrent.futures import ThreadPoolExecutor, wait, ALL_COMPLETED, as_completed def sleep_task(sleep_time): print('sleep time:{} s'.format(sleep_time))...
python并行计算---concurrent.futures模块的使用方法
qhu1600417010的博客
11-13 1428
在 Python 中，可序列化的对象意味着该对象可以被“序列化”（即转换成字节流），然后在不同进程之间传递。Python 使用 pickle 模块来实现这种序列化，因此所有传递给 ProcessPoolExecutor 的参数和返回值都必须是 pickle 支持的类型（例如基本数据类型、列表、字典、元组等）。
python线程池模块_Python 线程池模块threadpool 、 concurrent.futures 的 ThreadPoolExecutor
weixin_39700397的博客
11-28 367
一、threadpool 基本用法pip install threadpoolpool =ThreadPool(poolsize)requests=makeRequests(some_callable, list_of_args, callback)[pool.putRequest(req)for req inrequests]pool.wait()第一行定义了一个线程池，表示最多可以创建po...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值