Python：concurrent异步并行任务编程模块、 线程池、进程池、上下文管理

最新推荐文章于 2025-07-12 14:42:45 发布
最新推荐文章于 2025-07-12 14:42:45 发布
阅读量532 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： Python 文章标签： concurrent 线程池 多线程 多进程 上下文
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Smart_look/article/details/118267671
Python的concurrent包提供了高级的异步并行任务编程接口，包括ThreadPoolExecutor和ProcessPoolExecutor。ThreadPoolExecutor用于线程池，而ProcessPoolExecutor则用于进程池。concurrent模块支持上下文管理，使得使用with语句可以更方便地管理和关闭执行器。总结来说，这个模块简化了多线程和多进程编程，尽管无法直接设置线程名称。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

concurrent包

ThreadPoolExecutor对象

ProcessPoolExecutor对象

支持上线文管理

总结

concurrent包

3.2版本引入的模块。
异步并行任务编程模块，提供一个高级的异步可执行的便利接口。

提供2个池执行器：
ThreadPoolExcentor   异步调用线程池的Executor
ProcessPoolExecutor 异步调用的进程池的Executor

ThreadPoolExecutor对象

首先需要定义一个池的执行器对象，Exector子类对象

方法含义
ThreadPoolExector(max_workers=1)池中至多创建max_workers个线程的池来同时异步执行，返回Executor实例
submit(fn，*args，**kwargs)提交执行的函数及其参数，返回Future实例
shutdown(wait=True)清理池

Future类

方法含义
done()如果调用被成功的取消或者执行完成，返回True
cancelled()如果调用被成功的取消，返回True
running（）如果正在运行且不能被取消，返回True
cancel()尝试取消调用，如果已经执行且不能取消返回False，否则返回True
result(timeout=None)取消返回的结果，timeout为None，一直等待返回；timeout设置到期，抛出concurrent.futures.TimeoutError异常
exception(timeout=None)取返回的异常，timeout为None，一直等待返回；timeout设置到期，抛出concurrent.futures.TimeoutError异常
#ThreadPoolExecutor例子
import threading
import logging
import time
from concurrent import futures

#输出定义
FORMAT='%(asctime)-15s\t [%(processName)s:%(threadName)s,%(process)d:%(thread)8d] %(message)s'
logging.basicConfig(level=logging.INFO,format=FORMAT)

def worker(n):
    logging.info("begin to work{}".format(n))
    time.sleep(5)
    logging.info("finished {}".format(n))

#创建线程池，池的容量为3
exect = futures.ThreadPoolExecutor(max_workers=3)
fs = []
for i in range(3):
    future = exect.submit(worker,i)
    fs.append(future)

for i in range(3,6):
    future = exect.submit(worker,i)

while True:
    time.sleep(2)
    logging.info(threading.enumerate())

    flag = True
    for _ in fs:   #判断是否还有任务未完成
        logging.info(_.done())
        flag = flag and _.done()
    print("="*30)

    if flag:
        exect.shutdown()  #清理池，池中线程全部杀掉
        logging.info(threading.enumerate())
        break

#线程池一旦创建了，就不需要在频繁清楚
结果：
2021-06-27 16:06:37,177	 [MainProcess:ThreadPoolExecutor-0_0,20060:    9812] begin to work0
2021-06-27 16:06:37,177	 [MainProcess:ThreadPoolExecutor-0_1,20060:    2816] begin to work1
2021-06-27 16:06:37,177	 [MainProcess:ThreadPoolExecutor-0_2,20060:   13268] begin to work2
2021-06-27 16:06:39,178	 [MainProcess:MainThread,20060:   26076] [<_MainThread(MainThread, started 26076)>, <Thread(ThreadPoolExecutor-0_0, started daemon 9812)>, <Thread(ThreadPoolExecutor-0_1, started daemon 2816)>, <Thread(ThreadPoolExecutor-0_2, started daemon 13268)>]
2021-06-27 16:06:39,178	 [MainProcess:MainThread,20060:   26076] False
2021-06-27 16:06:39,178	 [MainProcess:MainThread,20060:   26076] False
2021-06-27 16:06:39,178	 [MainProcess:MainThread,20060:   26076] False
==============================
==============================
2021-06-27 16:06:41,179	 [MainProcess:MainThread,20060:   26076] [<_MainThread(MainThread, started 26076)>, <Thread(ThreadPoolExecutor-0_0, started daemon 9812)>, <Thread(ThreadPoolExecutor-0_1, started daemon 2816)>, <Thread(ThreadPoolExecutor-0_2, started daemon 13268)>]
2021-06-27 16:06:41,179	 [MainProcess:MainThread,20060:   26076] False
2021-06-27 16:06:41,179	 [MainProcess:MainThread,20060:   26076] False
2021-06-27 16:06:41,179	 [MainProcess:MainThread,20060:   26076] False
2021-06-27 16:06:42,179	 [MainProcess:ThreadPoolExecutor-0_2,20060:   13268] finished 2
2021-06-27 16:06:42,179	 [MainProcess:ThreadPoolExecutor-0_2,20060:   13268] begin to work3
2021-06-27 16:06:42,179	 [MainProcess:ThreadPoolExecutor-0_1,20060:    2816] finished 1
2021-06-27 16:06:42,179	 [MainProcess:ThreadPoolExecutor-0_1,20060:    2816] begin to work4
2021-06-27 16:06:42,179	 [MainProcess:ThreadPoolExecutor-0_0,20060:    9812] finished 0
2021-06-27 16:06:42,179	 [MainProcess:ThreadPoolExecutor-0_0,20060:    9812] begin to work5
2021-06-27 16:06:43,181	 [MainProcess:MainThread,20060:   26076] [<_MainThread(MainThread, started 26076)>, <Thread(ThreadPoolExecutor-0_0, started daemon 9812)>, <Thread(ThreadPoolExecutor-0_1, started daemon 2816)>, <Thread(ThreadPoolExecutor-0_2, started daemon 13268)>]
2021-06-27 16:06:43,181	 [MainProcess:MainThread,20060:   26076] True
2021-06-27 16:06:43,181	 [MainProcess:MainThread,20060:   26076] True
2021-06-27 16:06:43,181	 [MainProcess:MainThread,20060:   26076] True
==============================
2021-06-27 16:06:47,180	 [MainProcess:ThreadPoolExecutor-0_0,20060:    9812] finished 5
2021-06-27 16:06:47,180	 [MainProcess:ThreadPoolExecutor-0_2,20060:   13268] finished 3
2021-06-27 16:06:47,180	 [MainProcess:ThreadPoolExecutor-0_1,20060:    2816] finished 4
2021-06-27 16:06:47,180	 [MainProcess:MainThread,20060:   26076] [<_MainThread(MainThread, started 26076)>]

ProcessPoolExecutor对象

方法一样，就是是哦那个多进程
 

#ThreadPoolExecutor例子
import threading
import logging
import time
from concurrent import futures

#输出定义
FORMAT='%(asctime)-15s\t [%(processName)s:%(threadName)s,%(process)d:%(thread)8d] %(message)s'
logging.basicConfig(level=logging.INFO,format=FORMAT)

def worker(n):
    logging.info("begin to work{}".format(n))
    time.sleep(5)
    logging.info("finished {}".format(n))
if __name__ == '__main__':
    #创建线程池，池的容量为3
    exect = futures.ProcessPoolExecutor(max_workers=3)
    fs = []
    for i in range(3):
        future = exect.submit(worker,i)
        fs.append(future)

    for i in range(3,6):
        future = exect.submit(worker,i)

    while True:
        time.sleep(2)
        logging.info(threading.enumerate())     #多进程时看主线程已经没有必要了

        flag = True
        for _ in fs:   #判断是否还有任务未完成
            logging.info(_.done())
            flag = flag and _.done()
        print("="*30)

        if flag:
            exect.shutdown()  #清理池，池中线程全部杀掉
            logging.info(threading.enumerate())  #多进程时看主线程已经没有必要了
            break

    #线程池一旦创建了，就不需要在频繁清楚
结果：
2021-06-27 16:11:18,415	 [SpawnProcess-1:MainThread,25872:   25960] begin to work0
2021-06-27 16:11:18,421	 [SpawnProcess-2:MainThread,22072:   29224] begin to work1
2021-06-27 16:11:18,428	 [SpawnProcess-3:MainThread,18108:   20136] begin to work2
==============================
2021-06-27 16:11:20,345	 [MainProcess:MainThread,23556:   11200] [<_MainThread(MainThread, started 11200)>, <Thread(QueueManagerThread, started daemon 6588)>, <Thread(QueueFeederThread, started daemon 12680)>]
2021-06-27 16:11:20,345	 [MainProcess:MainThread,23556:   11200] False
2021-06-27 16:11:20,345	 [MainProcess:MainThread,23556:   11200] False
2021-06-27 16:11:20,345	 [MainProcess:MainThread,23556:   11200] False
2021-06-27 16:11:22,346	 [MainProcess:MainThread,23556:   11200] [<_MainThread(MainThread, started 11200)>, <Thread(QueueManagerThread, started daemon 6588)>, <Thread(QueueFeederThread, started daemon 12680)>]
2021-06-27 16:11:22,346	 [MainProcess:MainThread,23556:   11200] False
2021-06-27 16:11:22,346	 [MainProcess:MainThread,23556:   11200] False
2021-06-27 16:11:22,346	 [MainProcess:MainThread,23556:   11200] False
==============================
2021-06-27 16:11:23,417	 [SpawnProcess-1:MainThread,25872:   25960] finished 0
2021-06-27 16:11:23,417	 [SpawnProcess-1:MainThread,25872:   25960] begin to work3
2021-06-27 16:11:23,422	 [SpawnProcess-2:MainThread,22072:   29224] finished 1
2021-06-27 16:11:23,422	 [SpawnProcess-2:MainThread,22072:   29224] begin to work4
2021-06-27 16:11:23,430	 [SpawnProcess-3:MainThread,18108:   20136] finished 2
2021-06-27 16:11:23,430	 [SpawnProcess-3:MainThread,18108:   20136] begin to work5
2021-06-27 16:11:24,347	 [MainProcess:MainThread,23556:   11200] [<_MainThread(MainThread, started 11200)>, <Thread(QueueManagerThread, started daemon 6588)>, <Thread(QueueFeederThread, started daemon 12680)>]
2021-06-27 16:11:24,347	 [MainProcess:MainThread,23556:   11200] True
2021-06-27 16:11:24,347	 [MainProcess:MainThread,23556:   11200] True
2021-06-27 16:11:24,347	 [MainProcess:MainThread,23556:   11200] True
==============================
2021-06-27 16:11:28,419	 [SpawnProcess-1:MainThread,25872:   25960] finished 3
2021-06-27 16:11:28,423	 [SpawnProcess-2:MainThread,22072:   29224] finished 4
2021-06-27 16:11:28,431	 [SpawnProcess-3:MainThread,18108:   20136] finished 5
2021-06-27 16:11:28,441	 [MainProcess:MainThread,23556:   11200] [<_MainThread(MainThread, started 11200)>]

支持上线文管理

concurrent.futures.ProcessPoolExecutor继承自concurent.futures.base.Execurot，而父类有__enter__、__exit__方法，支持上下文管理。可以使用with语句

__exit__方法本质还是调用的shutdown(wait=True)，就是一直阻塞到所有运行的任务完成

使用方法

import threading
from concurrent import futures

with futures.ProcessPoolExecutor(max_workers=3) as executor:
    future = executor.submit(work,232,1235)
    print(future.result())

使用上下文改造上面的例子，增加返回计算的结果
 

#ThreadPoolExecutor例子
import threading
import logging
import time
from concurrent import futures

#输出定义
FORMAT='%(asctime)-15s\t [%(processName)s:%(threadName)s,%(process)d:%(thread)8d] %(message)s'
logging.basicConfig(level=logging.INFO,format=FORMAT)

def worker(n):
    logging.info("begin to work{}".format(n))
    time.sleep(5)
    logging.info("finished {}".format(n))
    return n + 100

if __name__ == '__main__':
    #创建线程池，池的容量为3
    exect = futures.ProcessPoolExecutor(max_workers=3)
    with exect:#上下文
        fs = []
        for i in range(3):
            future = exect.submit(worker,i)
            fs.append(future)

        for i in range(3,6):
            future = exect.submit(worker,i)

        while True:
            time.sleep(2)
            logging.info(threading.enumerate())     #多进程时看主线程已经没有必要了

            flag = True
            for _ in fs:   #判断是否还有任务未完成
                logging.info(_.done())
                flag = flag and _.done()
                if _.done():  #做完了，看下结果
                    logging.info("result = {}".format(_.result()))
            print("="*30)

            if flag:break
    # exect.shutdown()  #清理池，池中线程全部杀掉
    logging.info(threading.enumerate())  #多进程时看主线程已经没有必要了
                    

    #线程池一旦创建了，就不需要在频繁清楚
结果：
2021-06-27 16:28:04,265	 [SpawnProcess-1:MainThread,28816:   14260] begin to work0
2021-06-27 16:28:04,271	 [SpawnProcess-2:MainThread,28308:    9024] begin to work1
2021-06-27 16:28:04,277	 [SpawnProcess-3:MainThread,20960:    6168] begin to work2
2021-06-27 16:28:06,192	 [MainProcess:MainThread,1592:    8024] [<_MainThread(MainThread, started 8024)>, <Thread(QueueManagerThread, started daemon 26972)>, <Thread(QueueFeederThread, started daemon 16680)>]
2021-06-27 16:28:06,192	 [MainProcess:MainThread,1592:    8024] False
2021-06-27 16:28:06,192	 [MainProcess:MainThread,1592:    8024] False
2021-06-27 16:28:06,192	 [MainProcess:MainThread,1592:    8024] False
==============================
2021-06-27 16:28:08,194	 [MainProcess:MainThread,1592:    8024] [<_MainThread(MainThread, started 8024)>, <Thread(QueueManagerThread, started daemon 26972)>, <Thread(QueueFeederThread, started daemon 16680)>]
2021-06-27 16:28:08,194	 [MainProcess:MainThread,1592:    8024] False
2021-06-27 16:28:08,194	 [MainProcess:MainThread,1592:    8024] False
2021-06-27 16:28:08,194	 [MainProcess:MainThread,1592:    8024] False
==============================
2021-06-27 16:28:09,266	 [SpawnProcess-1:MainThread,28816:   14260] finished 0
2021-06-27 16:28:09,266	 [SpawnProcess-1:MainThread,28816:   14260] begin to work3
2021-06-27 16:28:09,272	 [SpawnProcess-2:MainThread,28308:    9024] finished 1
2021-06-27 16:28:09,272	 [SpawnProcess-2:MainThread,28308:    9024] begin to work4
2021-06-27 16:28:09,278	 [SpawnProcess-3:MainThread,20960:    6168] finished 2
2021-06-27 16:28:09,278	 [SpawnProcess-3:MainThread,20960:    6168] begin to work5
2021-06-27 16:28:10,196	 [MainProcess:MainThread,1592:    8024] [<_MainThread(MainThread, started 8024)>, <Thread(QueueManagerThread, started daemon 26972)>, <Thread(QueueFeederThread, started daemon 16680)>]
2021-06-27 16:28:10,196	 [MainProcess:MainThread,1592:    8024] True
2021-06-27 16:28:10,196	 [MainProcess:MainThread,1592:    8024] result = 100
2021-06-27 16:28:10,196	 [MainProcess:MainThread,1592:    8024] True
2021-06-27 16:28:10,196	 [MainProcess:MainThread,1592:    8024] result = 101
2021-06-27 16:28:10,196	 [MainProcess:MainThread,1592:    8024] True
2021-06-27 16:28:10,196	 [MainProcess:MainThread,1592:    8024] result = 102
==============================
2021-06-27 16:28:14,267	 [SpawnProcess-1:MainThread,28816:   14260] finished 3
2021-06-27 16:28:14,273	 [SpawnProcess-2:MainThread,28308:    9024] finished 4
2021-06-27 16:28:14,279	 [SpawnProcess-3:MainThread,20960:    6168] finished 5
2021-06-27 16:28:14,288	 [MainProcess:MainThread,1592:    8024] [<_MainThread(MainThread, started 8024)>]

总结

改库统一线程池、进程池调用，简化了编程；是Python简单的思想哲学的体现；唯一的缺点：无法设置线程名称，但这都是不值一提的

Python中的线程池与进程池：并行编程的高效选择
步入烟尘的博客
05-23 708
并行编程是提高程序性能和扩展性的重要手段，通过合理地利用多核处理器和分布式计算资源，可以实现任务的并行执行，加速程序的运行速度，处理大规模数据和复杂计算任务。本文介绍了在Python中进行并行编程的各种技术和方法，包括线程池、进程池、异常处理、数据同步与共享、高级并行编程技术等。首先，我们介绍了线程池和进程池作为实现并行编程的基本工具，它们分别适用于不同类型的任务和计算机资源的情况。然后，我们讨论了并发编程中常见的问题和解决方案，包括异常处理、数据同步与共享、监控与调优等。
Python并行编程技术与方法详解：线程池、进程池及优化策略
这家伙很懒，什么都没有留下
06-14 1384
在Python并行编程中，我们可以采用多种优化策略来提高程序的执行效率。根据任务的性质选择合适的并行编程技术。对于CPU密集型任务，可以使用进程池；对于I/O密集型任务，可以使用线程池或异步编程。合理设置线程池和进程池的大小，避免资源竞争和开销增大。拆分和合并任务，减少通信开销。使用队列、锁等同步机制来避免数据竞争和不一致性。选择合适的并行框架和库，如Celery、Dask等，它们提供了更高级别的并行处理能力和优化选项。优化算法和数据结构，减少不必要的计算和内存占用。
Python标准模块--concurrent.futures模块（ThreadPoolExecutor：线程池，提供异步调用、ProcessPoolExecutor: 进程池，提供异步调用）
。
11-16 6236
目录 ProcessPoolExecutor: 进程池 ThreadPoolExecutor：线程池  map的用法  回调函数 https://docs.python.org/dev/library/concurrent.futures.html 1 介绍 concurrent.futures模块提供了高度封装的异步调用接口 ThreadPoolExecutor：线程池，提供异步调用...
Python 并行任务技巧
weixin_33682719的博客
01-20 209
2019独角兽企业重金招聘Python工程师标准>>> ...
Python异步开发-concurrent
非-浪的博客
04-16 315
concurrent 两个类 Future 类 cancel()：尝试去取消调用。如果调用当前正在执行，不能被取消。这个方法将返回False，否则调用将会被取消，方法将返回True cancelled()：如果调用被成功取消返回True running()：如果当前正在被执行不能被取消返回True done()：如果调用被成功取消或者完成running返回True result(Timeout = None)：拿到调用返回的结果。如果没有执行完毕就会去等待 ; asyncio模块的res
Python的并行任务（进程池、线程池）
六月闻君
08-05 2144
在Python中，进程（Process）和线程（Thread）是并发编程的两种主要方式，它们各自适用于不同的场景。了解何时使用进程或线程，可以帮助你更有效地设计并发程序。 使用内置基本库concurrent.futures来实现并发，简单使用这个模块，包括并行线程和并行进程执行器 。
【Python】concurrent
宅男很神经
06-28 941
欢迎来到Python并发编程的深邃世界。在本章中，我们将首先建立对并发编程的根本理解，剖析其核心概念，并在此背景下，探究库为何应运而生，以及它在Python并发生态系统中的独特地位。我们不只是学习API，而是要从最底层开始，理解其背后哲学和设计初衷。在深入之前，我们必须厘清几个经常被混淆但意义截然不同的概念：并发（Concurrency）、并行（Parallelism）和异步（Asynchrony）。它们是构建高性能、高响应度应用程序的基石。并发是指在同一时间段内处理多个任务的能力。它不意味着这些任务在物理
Python中的concurrent并发包(构建线程池和进程池)
兰枫
06-11 3761
Python中的concurrent并发包(构建线程池和进程池) 文章目录Python中的concurrent并发包(构建线程池和进程池)ThreadPoolExecutor线程池与ProcessPoolExecutor进程池对象构造方法concurrent.futures.Future类，未来结果类concurrent.futures.wait方法上下文管理 concurrent.futures...
3.2. 多进程：concurrent.futures实现进程池
人生是一场修行
12-11 1179
异步的线程/进程池，concurrent.futures模块： 一次起指定数量的线程数，提交的任务在这些线程中跑，当线程中的任务执行完毕时，线程不会结束，而是保留资源，再次提交新的任务时在空闲的线程中跑新任务，而不会另起线程；优点是避免反复申请资源。
Python ThreadPoolExecutor 使用详解：线程池高效编程指南
最新发布
YAnt的博客
07-12 290
本教程是**Python线程池编程的权威指南**，深入解析`concurrent.futures.ThreadPoolExecutor`的核心原理与高级应用。通过**7个生产级代码案例**和**5种可视化流程图**，系统讲解线程池的创建、管理、监控与优化技术。
Python多线程Concurrent
frighting_ing的博客
06-29 1505
future的设计理念很棒，在线程池/进程池和携程中都存在future对象，是异步编程的核心。ThreadPoolExecutor 让线程的使用更加方便，减小了线程创建/销毁的资源损耗，无需考虑线程间的复杂同步，方便主线程与子线程的交互。线程池的抽象程度很高，多线程和多进程的编码接口一致。参考文章。
python程序中的线程操作 concurrent模块使用详解
python多线程基础教程进阶教程
02-10 882
这篇文章主要介绍了python程序中的线程操作 concurrent模块使用详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 文章目录一、concurrent模块的介绍二、基本方法三、进程池和线程池3.1 进程池3.2 线程池四、Map的用法五、同步和异步六、回调函数 一、concurrent模块的介绍 concurrent.futures模块...
python concurrent 模块
weixin_40513133的博客
07-23 149
concurrent 介绍登录后复制 concurrent.futures 是 Python 中的一个模块，提供了一个高级接口，用于异步执行函数或方法。 concurrent.futures 提供了2个池执行器： ThreadPoolExecutor：该类使用一组线程来异步执行调用。它适用于 I/O 密集型操作或不是...
Python concurrent 包
weixin_44983653的博客
04-22 1297
Python concurrent 包1、`concurrent.futures`2、`ThreadPoolExecutor`3、`ProcessPoolExecutor`4、`ProcessPoolExecutor` 支持上下文管理 1、concurrent.futures 异步并行任务编程模块，提供一个高级的异步可执行的便利接口。 提供了两个池执行器： ThreadPoolExecutor 异步调用的线程池的Executor ProcessPoolExecutor 异步调用的进程池的Execut
python 并行_Python 并行任务技巧
weixin_39946964的博客
12-01 104
感觉效果应该很好，但是看看这些代码！初始化方法、线程跟踪，最糟的是，如果你也和我一样是个容易犯死锁问题的人，这里的join语句就要出错了。这样就开始变得更加复杂了!到现在为止都做了些什么？基本上没什么。上面的代码都是些基础功能，而且很容易出错。(天啊，我忘了写上在队列对象上调用task_done()方法(我懒得修复这个问题在重新截图))，这真是性价比太低。所幸的是，我们有更好的办法.引入：MapM...
python并行处理任务_在python中并行执行任务
weixin_39945795的博客
12-10 286
I am using python 2.7, I have some code that looks like this:task1()task2()task3()dependent1()task4()task5()task6()dependent2()dependent3()The only dependencies here are as follows: dependent1 needs t...
python并行_在Python中实现多个任务并行
weixin_39806413的博客
12-29 1999
之前在Fortran中有讲到OpenMP的并行：这里讲如何在Python中如何实现多个任务的并行。在Python中，multiprocessing模块提供了一个Process类来代表一个进程对象。Python中只有一个线程(是单线程的)，所以是通过启动“进程”来实现并行；而在Fortran的OpenMP中是通过启动“线程”来实现并行。这是实现多任务并行常见的两种解决方案。直观的理解就是打开电脑的任...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值