Python-- concurrent包（异步并行任务编程模块）

鹿夏 鹿夏 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 800+累计阅读 887平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄8年
关注
原创 最新推荐文章于 2026-03-23 00:46:31 发布 887 阅读 AI 写同款· GEO 优化 ›
Python中使用concurrent执行多进程任务 多进程技术是独立于算法任务本身的一种优化技术，通过python中的concurrent库，我们可以非常容易的实现多进程的任务，用来优化已有的算法。这里我们也给出了一些多进程配置信息的参考方案，在GPU和超算相关的领域上，都能够发挥较大的用途。 阅读详情

concurrent包

concurrent.futures

3.2版本引入的模块

  • 异步并行任务编程模块，提供一个高级的异步可执行的便利接口
  • 提供了2个池执行器
    ThreadPoolExecutor 异步调用的线程池的Executor
    ProcessPoolExecutor 异步调用的进程池的Executor

ThreadPoolExecutor对象

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

方法含义
ThreadPoolExecutor(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
from concurrent import futures
import logging
import time

# 输出格式定义
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
executer = futures.ThreadPoolExecutor(max_workers=3)
fs = []
for i in range(3):
    future = executer.submit(worker, i)
    fs.append(future)

for i in range(3, 6):
    future = executer.submit(worker, i)
    fs.append(future)

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

    flag = True
    for f in fs: # 判断是否还有未完成的任务
        logging.info(f.done())
        flag = flag and f.done()
        # if not flag: # 注释了这个if，方便观看输出的日志
        #     break

    print('-' * 30)
    if flag:
        executer.shutdown()
        logging.info(threading.enumerate())
        break

线程池一旦创建了线程，就不需要频繁清除

  • 执行结果
2019-06-11 16:10:53,824	 [MainProcess:ThreadPoolExecutor-0_0, 341824:  341040] begin to work-0
2019-06-11 16:10:53,824	 [MainProcess:ThreadPoolExecutor-0_1, 341824:  341248] begin to work-1
2019-06-11 16:10:53,826	 [MainProcess:ThreadPoolExecutor-0_2, 341824:  335160] begin to work-2
2019-06-11 16:10:55,828	 [MainProcess:MainThread, 341824:  339368] [<_MainThread(MainThread, started 339368)>, <Thread(ThreadPoolExecutor-0_0, started daemon 341040)>, <Thread(ThreadPoolExecutor-0_1, started daemon 341248)>, <Thread(ThreadPoolExecutor-0_2, started daemon 335160)>]
2019-06-11 16:10:55,828	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:10:55,828	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:10:55,829	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:10:55,829	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:10:55,829	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:10:55,829	 [MainProcess:MainThread, 341824:  339368] False
------------------------------
------------------------------
2019-06-11 16:10:57,829	 [MainProcess:MainThread, 341824:  339368] [<_MainThread(MainThread, started 339368)>, <Thread(ThreadPoolExecutor-0_0, started daemon 341040)>, <Thread(ThreadPoolExecutor-0_1, started daemon 341248)>, <Thread(ThreadPoolExecutor-0_2, started daemon 335160)>]
2019-06-11 16:10:57,829	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:10:57,829	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:10:57,830	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:10:57,830	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:10:57,830	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:10:57,830	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:10:58,825	 [MainProcess:ThreadPoolExecutor-0_0, 341824:  341040] finished 0
2019-06-11 16:10:58,825	 [MainProcess:ThreadPoolExecutor-0_0, 341824:  341040] begin to work-3
2019-06-11 16:10:58,826	 [MainProcess:ThreadPoolExecutor-0_1, 341824:  341248] finished 1
2019-06-11 16:10:58,826	 [MainProcess:ThreadPoolExecutor-0_1, 341824:  341248] begin to work-4
2019-06-11 16:10:58,827	 [MainProcess:ThreadPoolExecutor-0_2, 341824:  335160] finished 2
2019-06-11 16:10:58,827	 [MainProcess:ThreadPoolExecutor-0_2, 341824:  335160] begin to work-5
2019-06-11 16:10:59,830	 [MainProcess:MainThread, 341824:  339368] [<_MainThread(MainThread, started 339368)>, <Thread(ThreadPoolExecutor-0_0, started daemon 341040)>, <Thread(ThreadPoolExecutor-0_1, started daemon 341248)>, <Thread(ThreadPoolExecutor-0_2, started daemon 335160)>]
2019-06-11 16:10:59,830	 [MainProcess:MainThread, 341824:  339368] True
2019-06-11 16:10:59,831	 [MainProcess:MainThread, 341824:  339368] True
2019-06-11 16:10:59,831	 [MainProcess:MainThread, 341824:  339368] True
2019-06-11 16:10:59,831	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:10:59,831	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:10:59,831	 [MainProcess:MainThread, 341824:  339368] False
------------------------------
------------------------------
2019-06-11 16:11:01,832	 [MainProcess:MainThread, 341824:  339368] [<_MainThread(MainThread, started 339368)>, <Thread(ThreadPoolExecutor-0_0, started daemon 341040)>, <Thread(ThreadPoolExecutor-0_1, started daemon 341248)>, <Thread(ThreadPoolExecutor-0_2, started daemon 335160)>]
2019-06-11 16:11:01,832	 [MainProcess:MainThread, 341824:  339368] True
2019-06-11 16:11:01,832	 [MainProcess:MainThread, 341824:  339368] True
2019-06-11 16:11:01,832	 [MainProcess:MainThread, 341824:  339368] True
2019-06-11 16:11:01,832	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:11:01,832	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:11:01,832	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:11:03,826	 [MainProcess:ThreadPoolExecutor-0_0, 341824:  341040] finished 3
2019-06-11 16:11:03,827	 [MainProcess:ThreadPoolExecutor-0_1, 341824:  341248] finished 4
2019-06-11 16:11:03,827	 [MainProcess:ThreadPoolExecutor-0_2, 341824:  335160] finished 5
------------------------------
2019-06-11 16:11:03,832	 [MainProcess:MainThread, 341824:  339368] [<_MainThread(MainThread, started 339368)>, <Thread(ThreadPoolExecutor-0_0, started daemon 341040)>, <Thread(ThreadPoolExecutor-0_1, started daemon 341248)>, <Thread(ThreadPoolExecutor-0_2, started daemon 335160)>]
2019-06-11 16:11:03,832	 [MainProcess:MainThread, 341824:  339368] True
2019-06-11 16:11:03,832	 [MainProcess:MainThread, 341824:  339368] True
2019-06-11 16:11:03,832	 [MainProcess:MainThread, 341824:  339368] True
2019-06-11 16:11:03,832	 [MainProcess:MainThread, 341824:  339368] True
2019-06-11 16:11:03,832	 [MainProcess:MainThread, 341824:  339368] True
2019-06-11 16:11:03,832	 [MainProcess:MainThread, 341824:  339368] True
2019-06-11 16:11:03,833	 [MainProcess:MainThread, 341824:  339368] [<_MainThread(MainThread, started 339368)>]

Process finished with exit code 0

ProcessPoolExecutor对象

  • 方法一样，就是使用多进程完成

ProcessPoolExecutor例子

import threading
from concurrent import futures
import logging
import time

# 输出格式定义
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
    executer = futures.ProcessPoolExecutor(max_workers=3)
    fs = []
    for i in range(3):
        future = executer.submit(worker, i)
        fs.append(future)

    for i in range(3, 6):
        futuer = executer.submit(worker, i)
        fs.append(future)

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

        flag = True
        for f in fs: # 判断是否还有未完成的任务
            logging.info(f.done())
            flag = flag and f.done()
            # if not flag: # 注释了这个if，方便观看输出的日志
            #     break

        print('-' * 30)

        if flag:
            executer.shutdown() # 清理池。除非不用了，否则不要频繁清理池
            logging.info(threading.enumerate()) # 多进程时看主线程已经没有必要了
            break
  • 执行结果
2019-06-11 16:22:34,441	 [Process-2:MainThread, 343300:  343320] begin to work-0
2019-06-11 16:22:34,466	 [Process-1:MainThread, 343260:  343312] begin to work-1
2019-06-11 16:22:34,488	 [Process-3:MainThread, 343232:  343328] begin to work-2
2019-06-11 16:22:36,201	 [MainProcess:MainThread, 343224:  343220] [<_MainThread(MainThread, started 343220)>, <Thread(Thread-1, started daemon 343284)>, <Thread(QueueFeederThread, started daemon 343168)>]
------------------------------
2019-06-11 16:22:36,201	 [MainProcess:MainThread, 343224:  343220] False
2019-06-11 16:22:36,201	 [MainProcess:MainThread, 343224:  343220] False
2019-06-11 16:22:36,201	 [MainProcess:MainThread, 343224:  343220] False
2019-06-11 16:22:36,201	 [MainProcess:MainThread, 343224:  343220] False
2019-06-11 16:22:36,201	 [MainProcess:MainThread, 343224:  343220] False
2019-06-11 16:22:36,201	 [MainProcess:MainThread, 343224:  343220] False
------------------------------
2019-06-11 16:22:38,201	 [MainProcess:MainThread, 343224:  343220] [<_MainThread(MainThread, started 343220)>, <Thread(Thread-1, started daemon 343284)>, <Thread(QueueFeederThread, started daemon 343168)>]
2019-06-11 16:22:38,201	 [MainProcess:MainThread, 343224:  343220] False
2019-06-11 16:22:38,202	 [MainProcess:MainThread, 343224:  343220] False
2019-06-11 16:22:38,202	 [MainProcess:MainThread, 343224:  343220] False
2019-06-11 16:22:38,202	 [MainProcess:MainThread, 343224:  343220] False
2019-06-11 16:22:38,202	 [MainProcess:MainThread, 343224:  343220] False
2019-06-11 16:22:38,202	 [MainProcess:MainThread, 343224:  343220] False
2019-06-11 16:22:39,442	 [Process-2:MainThread, 343300:  343320] finished 0
2019-06-11 16:22:39,442	 [Process-2:MainThread, 343300:  343320] begin to work-3
2019-06-11 16:22:39,467	 [Process-1:MainThread, 343260:  343312] finished 1
2019-06-11 16:22:39,467	 [Process-1:MainThread, 343260:  343312] begin to work-4
2019-06-11 16:22:39,488	 [Process-3:MainThread, 343232:  343328] finished 2
2019-06-11 16:22:39,488	 [Process-3:MainThread, 343232:  343328] begin to work-5
------------------------------
2019-06-11 16:22:40,202	 [MainProcess:MainThread, 343224:  343220] [<_MainThread(MainThread, started 343220)>, <Thread(Thread-1, started daemon 343284)>, <Thread(QueueFeederThread, started daemon 343168)>]
2019-06-11 16:22:40,202	 [MainProcess:MainThread, 343224:  343220] True
2019-06-11 16:22:40,202	 [MainProcess:MainThread, 343224:  343220] True
2019-06-11 16:22:40,202	 [MainProcess:MainThread, 343224:  343220] True
2019-06-11 16:22:40,202	 [MainProcess:MainThread, 343224:  343220] True
2019-06-11 16:22:40,202	 [MainProcess:MainThread, 343224:  343220] True
2019-06-11 16:22:40,202	 [MainProcess:MainThread, 343224:  343220] True
2019-06-11 16:22:44,442	 [Process-2:MainThread, 343300:  343320] finished 3
2019-06-11 16:22:44,468	 [Process-1:MainThread, 343260:  343312] finished 4
2019-06-11 16:22:44,488	 [Process-3:MainThread, 343232:  343328] finished 5
2019-06-11 16:22:44,511	 [MainProcess:MainThread, 343224:  343220] [<_MainThread(MainThread, started 343220)>]

Process finished with exit code 0

支持上下文管理

  • concurrent.futures.ProcessPoolExecutor继承自concurrent.futures._base.Executor，而父类有__enter__ 、__exit__方法，支持上下文管理。可以使用with语句
  • __exit__方法本质还是调用的shutdown(wait=True)，就是一直阻塞到所有运行的任务完成

使用方法

with ThreadPoolExecutor(max_workers=1) as executor:
	future = executor.submit(pow, 323, 1235)
	print(future.result())
  • 使用上下文改造上面的例子，增加返回计算的结果

ProcessPoolExecutor 上下文例子

import threading
from concurrent import futures
import logging
import time

# 输出格式定义
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
    executer = futures.ProcessPoolExecutor(max_workers=3)

    with executer: # 上下文管理
        fs = []
        for i in range(3):
            future = executer.submit(worker, i)
            fs.append(future)

        for i in range(3, 6):
            futuer = executer.submit(worker, i)
            fs.append(future)

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

            flag = True
            for f in fs: # 判断是否还有未完成的任务
                logging.info(f.done())
                flag = flag and f.done()
                # if not flag: # 注释了这个if，方便观看输出的日志
                #     break

            print('-' * 30)

            if flag:
                break
        # executer.shutdown() # 上下文清理了资源
    logging.info('===end===')
    logging.info(threading.enumerate()) # 多进程时看主线程已经没有必要了
  • 执行结果
2019-06-11 16:48:06,023	 [Process-2:MainThread, 344928:  346108] begin to work-0
2019-06-11 16:48:06,040	 [Process-1:MainThread, 342556:  343704] begin to work-1
2019-06-11 16:48:06,044	 [Process-3:MainThread, 334452:  344428] begin to work-2
2019-06-11 16:48:07,761	 [MainProcess:MainThread, 346100:  346096] [<_MainThread(MainThread, started 346096)>, <Thread(Thread-1, started daemon 342024)>, <Thread(QueueFeederThread, started daemon 343912)>]
2019-06-11 16:48:07,761	 [MainProcess:MainThread, 346100:  346096] False
2019-06-11 16:48:07,762	 [MainProcess:MainThread, 346100:  346096] False
2019-06-11 16:48:07,762	 [MainProcess:MainThread, 346100:  346096] False
2019-06-11 16:48:07,762	 [MainProcess:MainThread, 346100:  346096] False
2019-06-11 16:48:07,762	 [MainProcess:MainThread, 346100:  346096] False
2019-06-11 16:48:07,762	 [MainProcess:MainThread, 346100:  346096] False
------------------------------
2019-06-11 16:48:09,762	 [MainProcess:MainThread, 346100:  346096] [<_MainThread(MainThread, started 346096)>, <Thread(Thread-1, started daemon 342024)>, <Thread(QueueFeederThread, started daemon 343912)>]
2019-06-11 16:48:09,762	 [MainProcess:MainThread, 346100:  346096] False
2019-06-11 16:48:09,762	 [MainProcess:MainThread, 346100:  346096] False
2019-06-11 16:48:09,762	 [MainProcess:MainThread, 346100:  346096] False
2019-06-11 16:48:09,762	 [MainProcess:MainThread, 346100:  346096] False
2019-06-11 16:48:09,762	 [MainProcess:MainThread, 346100:  346096] False
2019-06-11 16:48:09,763	 [MainProcess:MainThread, 346100:  346096] False
------------------------------
2019-06-11 16:48:11,023	 [Process-2:MainThread, 344928:  346108] finished 0
2019-06-11 16:48:11,024	 [Process-2:MainThread, 344928:  346108] begin to work-3
2019-06-11 16:48:11,041	 [Process-1:MainThread, 342556:  343704] finished 1
2019-06-11 16:48:11,042	 [Process-1:MainThread, 342556:  343704] begin to work-4
2019-06-11 16:48:11,044	 [Process-3:MainThread, 334452:  344428] finished 2
2019-06-11 16:48:11,045	 [Process-3:MainThread, 334452:  344428] begin to work-5
------------------------------
2019-06-11 16:48:11,763	 [MainProcess:MainThread, 346100:  346096] [<_MainThread(MainThread, started 346096)>, <Thread(Thread-1, started daemon 342024)>, <Thread(QueueFeederThread, started daemon 343912)>]
2019-06-11 16:48:11,763	 [MainProcess:MainThread, 346100:  346096] True
2019-06-11 16:48:11,763	 [MainProcess:MainThread, 346100:  346096] True
2019-06-11 16:48:11,763	 [MainProcess:MainThread, 346100:  346096] True
2019-06-11 16:48:11,763	 [MainProcess:MainThread, 346100:  346096] True
2019-06-11 16:48:11,763	 [MainProcess:MainThread, 346100:  346096] True
2019-06-11 16:48:11,763	 [MainProcess:MainThread, 346100:  346096] True
2019-06-11 16:48:16,024	 [Process-2:MainThread, 344928:  346108] finished 3
2019-06-11 16:48:16,042	 [Process-1:MainThread, 342556:  343704] finished 4
2019-06-11 16:48:16,045	 [Process-3:MainThread, 334452:  344428] finished 5
2019-06-11 16:48:16,077	 [MainProcess:MainThread, 346100:  346096] ===end===
2019-06-11 16:48:16,077	 [MainProcess:MainThread, 346100:  346096] [<_MainThread(MainThread, started 346096)>]

Process finished with exit code 0

总结

  • 该库统一了线程池、进程池调用，简化了编程。
  • 是Python简单的思想哲学的体现。
  • 唯一的缺点：无法设置线程名称。但这都不值一提。
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
【Python】concurrent 欢迎来到Python并发编程的深邃世界。在本章中，我们将首先建立对并发编程的根本理解，剖析其核心概念，并在此背景下，探究库为何应运而生，以及它在Python并发生态系统中的独特地位。我们不只是学习API，而是要从最底层开始，理解其背后哲学和设计初衷。在深入之前，我们必须厘清几个经常被混淆但意义截然不同的概念：并发（Concurrency）、并行（Parallelism）和异步（Asynchrony）。它们是构建高性能、高响应度应用程序的基石。并发是指在同一时间段内处理多个任务的能力。它不意味着这些任务在物理 阅读详情

相关推荐

Python中的concurrent并发包(构建线程池和进程池)

Python中的concurrent并发包(构建线程池和进程池) 文章目录Python中的concurrent并发包(构建线程池和进程池)ThreadPoolExecutor线程池与ProcessPoolExecutor进程池对象构造方法concurrent.futures.Future类，未来结果类concurrent.futures.wait方法上下文管理 concurrent.futures...

兰枫 3846

python并发之concurrent快速入门

导读：我很笨，但是我很快——计算机之所以计算能力如此出众，不在于其有多智能，而是因为它超快的执行速度，而多核心则可以进一步成倍的提高效率。在python中，concurrent库就是用于...

小数志 5425

Python 中 concurrent.futures 模块使用说明

Python 中 concurrent.futures 模块使用说明 文章目录Python 中 concurrent.futures 模块使用说明0. 参考资料1. 概述2. Executor Object 执行器对象3. ThreadPoolExecutor 线程池执行器4. ThreadPoolExecutor 例子5. ProcessPoolExecutor 进程池执行器6. Proces...

团子大圆帅的博客 2万+

Python多线程Concurrent

future的设计理念很棒，在线程池/进程池和携程中都存在future对象，是异步编程的核心。ThreadPoolExecutor 让线程的使用更加方便，减小了线程创建/销毁的资源损耗，无需考虑线程间的复杂同步，方便主线程与子线程的交互。线程池的抽象程度很高，多线程和多进程的编码接口一致。参考文章。

frighting_ing的博客 1716

Python concurrent包介绍

concurrent 包是 Python 用于实现并发编程的一个重要工具集，它通过提供高层次的接口来管理并发执行的任务，简化了并发编程的复杂性。

qq_27390023的博客 1079

Python concurrent 包

Python concurrent 包1、`concurrent.futures`2、`ThreadPoolExecutor`3、`ProcessPoolExecutor`4、`ProcessPoolExecutor` 支持上下文管理 1、concurrent.futures 异步并行任务编程模块，提供一个高级的异步可执行的便利接口。 提供了两个池执行器： ThreadPoolExecutor 异步调用的线程池的Executor ProcessPoolExecutor 异步调用的进程池的Execut

weixin_44983653的博客 1385

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

目录 concurrent包 ThreadPoolExecutor对象 ProcessPoolExecutor对象 支持上线文管理 总结 concurrent包 3.2版本引入的模块。 异步并行任务编程模块，提供一个高级的异步可执行的便利接口。 提供2个池执行器：ThreadPoolExcentor 异步调用线程池的Executor ProcessPoolExecutor 异步调用的进程池的Executor ThreadPoolExecutor对象 首先需要定义一个池的执行器对..

二十四桥明月夜 595

高效Python并发编程：使用concurrent.futures模块

本文深入探讨了Python的concurrent.futures模块，详细介绍了如何利用ThreadPoolExecutor和ProcessPoolExecutor来执行并行任务，管理I/O密集型和CPU密集型任务。文章提供了实际代码示例，演示了如何创建执行器、提交任务、获取结果、处理异常以及管理任务执行的最佳实践。通过理解Future对象、跟踪任务进度、处理超时和管理结果，开发者能够构建出更加健壮和高效的并发应用程序。

weixin_36078669的博客 877

python3的concurrent包

concurrent包 concurrent.futures 3.2版本引入的模块. 异步并行任务编程模块, 提供一个高级的一部可执行的便利接口. 提供两个池执行器 ThreadPoolExecutor 异步调用的线程池的Executor ProcessPlloExecutor异步调用进程池的Executor 这两个池是惰性的, 不会立即创建线/进程 ThreadPoolExecutor对象 首先...

haihaihai2232的博客 3486

AD | Altium Designer(原理图设计、电路仿真、PCB绘图)汉化版

Altium Designer(原理图设计、电路仿真、PCB绘图)

Qt历险记，专注Qt技术，三年医疗设备研发经验，1年机器视觉研发经验，半年柔性传感研发经验。 4164

计算机网络-自顶向下方法 第三章课后习题答案（第七版）

复习题 R1. a) 就叫这个协议为简单传输协议STP（Simple Transport Protocol）。在发送方，STP从发送进程接收不超过1196字节的数据块、目标主机地址和目标端口号。STP向每个块添加一个4字节的头，并将目标进程的端口号放在头中。STP然后将目标主机地址和结果段提供给网络层。网络层将段交付给目的地主机的STP。目的主机基于STP检查段中的端口号，从段中提取数据，并将数据传递给由端口号标识的进程。 b) 在发送方，STP从发送进程接收不超过1192字节的数据块、目标主机地址和目标端

Erekilu的博客 2万+

3 - Python内置模块 - concurrent模块

文章目录 1 conturrent包 2 future模块 3 ThreadPoolExecutor对象 4 Future对象 5 ProcessPoolExecutor对象 6 支持上下文管理 7 异步爬网站的小例子 1 conturrent包 conturrent包内只包含了一个future模块，它为异步执行调用提供了高级的接口。 2 future模块 主要提供了两个用于异步执行的类：...

大欣的IT之路 1386

激光光束质量评估与光斑尺寸计算：从理论到MATLAB实践

本文详细解析激光光束质量评估与光斑尺寸计算的理论基础及MATLAB实践方法，重点介绍M²因子的测量与应用。通过高斯光束模型、CCD成像法和MATLAB算法实现，帮助读者掌握从理论到实践的完整流程，提升激光系统调试与评估能力。

weixin_29083373的博客 444

concurrent包

concurrent.futures 3.2版本引入模块 异步并行任务编程模块，提供一个高级的异步可执行的便利接口。 提供了2个池执行器 ThreadPoolExecutor异步调用的线程池的Executor ProcessPoolExecutor异步调用的进程池的Executor ThreadPoolExecutor 首先需要定义一个池的执行器对象，Executor类子类对象 方法 含义...

都枯槐的博客 565

探索Python融合地学：一文解决osgeo库安装失败问题

总结一下，要安装osgeo模块，关键在GDAL依赖库的安装，如果能够顺利安装GDAL依赖库，因其是osego的模块，因此osgeo的部分模块也能够得到自动安装，此时再运行代码，发现代码并不报错，能够正常运行了。第一步，我们要安装imagecodecs库，它支持多种常见的图像格式，当然也包含我们的目标tif格式，为方便后续的图像处理和安装osgeo模块，先安装此库。目前GDAL已经更新到了3.10版本，这里主要看你的Python版本是上面，小编用的是Python3.13，电脑是64位的，因此，我们选择。

Promising_GEO的博客 5461

Materials Studio多层聚合物建模全流程：从Build Layers到LAMMPS data文件导出避坑指南

本文详细解析了使用Materials Studio构建多层聚合物模型并导出为LAMMPS data文件的全流程。重点剖析了Build Layers工具的核心逻辑、真空层处理技巧，并提供了解决导出过程中Z轴坐标偏移问题的实战方案，特别是如何利用msi2lmp工具的-shift参数进行精准校正，确保模型在LAMMPS中模拟的稳定性和准确性。

hhh00的博客 913

Python 并发编程利器：concurrent.futures 模块详解

模块在 Python 3.2 版本中被引入，它抽象了线程和进程的底层细节，提供了统一的接口来管理并发任务的执行。和，分别用于创建线程池和进程池。通过这两个类，我们可以将任务提交到线程池或进程池中异步执行，并获取任务的执行结果。模块为 Python 开发者提供了一种简单而强大的方式来实现并发编程。通过和可以方便地创建线程池和进程池，处理不同类型的并发任务。Future对象则提供了对异步任务结果的管理和获取机制。在实际应用中，根据任务的特点选择合适的执行器，可以显著提升程序的性能和效率。

Tekin 是深耕技术 20 年的全栈实战派专家，精通 Go/Python/Java 等多语言开发。博客专注技术原理与实战结合，深度解析 Python 高阶编程、Go 语言架构、数据库优化等硬核内容。涵盖并发编程、机器学习、云原生等前沿领域，通过真实案例拆 1745

在mdk文件移植太多_XCubeClassB代码 的移植

前言ST在www.st.com官网上提供了针对IEC60730/IEC60335 ClassB认证的软件包。软件包分为三个，分别适用STM8，STM32(基于标准外设库)和STM32(基于HAL库)：STM8-SafeCLASSB，STM32-CLASSB-SPL，X-CUBE-CLASSB。本文以X-CUBE-CLASSB为例介绍如何做代码的移植以及经常遇到的问题的解决办法。X-CUB...

weixin_28898707的博客 1832

Python中concurrent.futures模块

&nbsp; 　 Python标准库为我们提供了threading和multiprocessing模块编写相应的异步多线程/多进程代码。从Python3.2开始，标准库为我们提供了concurrent.futures模块，它提供了ThreadPoolExecutor和ProcessPoolExecutor两个类ThreadPoolExecutor和ProcessPoolExecutor继承了E...

frank的博客 3248

Lammps纳米压痕接触面积—Matlab接触面积计算（两种方法）

Lammps纳米压痕接触面积计算

Rockyoung 5447

让openclaw接入web端的deepseek或着qwen，使用无限token

🪟 Windows: 提供原生的 PowerShell 一键安装支持！配置过程和官方版本是相同的，唯一的区别就是再选则model时要选择带Browser字样的deepseek或者qwen。安装之前需要先清理官方版本的安装痕迹，否则openclaw版本跳转不到这个中文版本。因为此版本与官方版本存在代差，在配置飞书时可能会出现无法安装飞书的情况。剩下的配置保持和官方版本一致操作即可。选中之后需要进行一次网页端的登录。登录后会出现可选择的model。安装完成后会跳到这个中文界面。涉及到接入飞书机器人的操作。

z1872385的博客 302

Python 库手册：concurrent.futures 并发编程模块

concurrent.futures 是 Python 从 3.2 开始引入的一个并发编程标准库，提供高级接口，用于执行异步任务。它基于线程（ThreadPoolExecutor）或进程（ProcessPoolExecutor）池，通过统一的 API 管理多个任务的提交与执行，显著简化了并发编程的复杂。与传统的 threading 和 multiprocessing 相比，concurrent.futures 更适合管理大量独立任务，如 I/O 密集型请求或 CPU 密集型计算。

qq_41176800的博客 1078

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf：最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版，包括SDIO 接口的外设，SDIO 接口官方协议等。

Python3.2+ 的 concurrent.futures 模块

Python 因为其全局解释器锁 GIL 而无法通过线程实现真正的平行计算。但是 Python 的concurrent.futures 模块可以利用 multiprocessing 实现真正的平行计算。 原理：concurrent.futures 会以子进程的形式，平行的运行多个 python 解释器，从而令 python 程序可以利用多核 CPU 来提升执行速度。由于 子进程 与 主解释器 相分离，所以他们的全局解释器锁也是相互独立的。每个子进程都能够完整的使用一个CPU 内核。 解释 2：

freeking101的博客 5380

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

文档：亲测可用解决vnc灰屏，黑屏，鼠标大黑叉情况

主要解决vnc-viewer灰屏，黑屏，鼠标大黑叉等现象，详细见文档。

Python的并行编程:multiprocessing与concurrent.futures

1.背景介绍 1. 背景介绍 在现代计算机科学中，并行编程是一种重要的技术，它可以让我们更有效地利用多核处理器和分布式系统来解决复杂的计算问题。Python是一种非常流行的编程语言，它提供了多种并行编程库来帮助开发者实现并行计算。在本文中，我们将深入探讨Python的并行编程，特别关注multiprocessing和concurrent.futures这两个库。 multiprocessin...

AI天才研究院 2557

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

python concurrent.futures 模块线程处理详解

介绍 从Python3.2开始，标准库为我们提供了 concurrent.futures 模块，它提供了 ThreadPoolExecutor (线程池)和ProcessPoolExecutor (进程池)两个类。 相比 threading 等模块，该模块通过 submit 返回的是一个 future 对象，它是一个未来可期的对象，通过它可以获悉线程的状态主线程(或进程)中可以获取某一个线程(进程)执行的状态或者某一个任务执行的状态及返回值： 主线程可以获取某一个线程（或者任务的）的状态，以及返回值。 当

爱死亡机器人 9159

python concurrent 模块

concurrent 介绍登录后复制 concurrent.futures 是 Python 中的一个模块，提供了一个高级接口，用于异步执行函数或方法。 concurrent.futures 提供了2个池执行器： ThreadPoolExecutor：该类使用一组线程来异步执行调用。它适用于 I/O 密集型操作或不是...

weixin_40513133的博客 262
上一篇： Linux中的特殊进程
下一篇： Python -- logging日志处理模块
点赞 0
评论 0
书签 书签 0
鹿夏
鹿夏
博客等级 码龄8年 24粉丝 105原创
+ 关注
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值