并行运行多个调用使用Futures生成对象
是一种并发编程的技术，它允许同时执行多个任务并在后续需要时获取它们的结果。Futures生成对象是一种表示异步操作结果的容器，可以在后台执行任务，并在需要时获取任务的结果。
优势：
- 提高性能：通过并行运行多个调用，可以充分利用计算资源，提高系统的处理能力和响应速度。
- 提高可扩展性：使用Futures生成对象可以轻松地将任务分解为多个子任务，并行执行，从而实现系统的可扩展性。
- 提高代码可读性：通过使用Futures生成对象，可以将异步操作的代码逻辑清晰地表达出来，提高代码的可读性和可维护性。
应用场景：
- 并行计算：当需要同时执行多个计算密集型任务时，可以使用Futures生成对象来并行运行这些任务，提高计算效率。
- 异步IO操作：当需要同时处理多个IO操作时，可以使用Futures生成对象来并行执行这些操作，提高系统的响应速度。
- 批量任务处理：当需要处理大量的任务时，可以使用Futures生成对象将任务分解为多个子任务，并行执行，提高处理效率。
推荐的腾讯云相关产品： 腾讯云提供了一系列与并行运行多个调用相关的产品和服务，包括：
- 云函数（Cloud Function）：腾讯云的无服务器计算服务，可以通过函数的方式并行运行多个调用。 产品介绍链接：https://cloud.tencent.com/product/scf
- 弹性MapReduce（EMR）：腾讯云的大数据处理平台，可以并行处理大规模数据集。 产品介绍链接：https://cloud.tencent.com/product/emr
- 弹性容器实例（Elastic Container Instance）：腾讯云的容器服务，可以并行运行多个容器实例。 产品介绍链接：https://cloud.tencent.com/product/eci
通过使用以上腾讯云的产品，可以实现并行运行多个调用的需求，并提供稳定可靠的云计算服务。
相关·内容
我将介绍Python concurrent.futures模块，并使用它来更熟悉并行/并发编程模型。不幸的是，由于它是一个相对较新的模块，我找不到大量面向初学者的文献。
我知道map()返回通过进程或线程在迭代器上调用的函数的直接返回值。submit()返回一个未来对象。
我想要更多的解释为什么其中一个可能选择使用一个或另一个。似乎map()更适合不需要协调的明显并行的任务。对于复杂的并发用例，submit()可能更有用。然而，我对此还是很陌生的，我希望更有知识的人可以扩展。
谢谢。
浏览 6提问于2012-08-30得票数 4
我正在创建一个程序，它可以从多个远程站点(~200)中同步数据。有时，每个站点有多个文件，不应该同时与多组站点联系，否则连接将关闭。目前，我有一个异步例程(在python中使用异步)，它可以同时同步所有文件(到它们各自的站点)。这将导致连接关闭，如果我们得到一个文件的积压或联系站是在同一组在同一时间。
我需要做的是创建分组任务，在这个任务组中，它在启动下一个文件之前等待上一个文件更新(updateFile())，但同时异步运行所有的站点组。
新的异步编程，我只是不知道如何使这个问题工作。
目前，我已经成功地异步运行了所有的东西。
起动回路
loop = asyncio.get_event_lo
浏览 6提问于2019-11-05得票数 1
回答已采纳
1回答
我有一个像这样的循环： df = []
for i in range(50):
if i <= 10:
df.append(i)
else:
df.append(i+1000) 我想用多进程来运行它，就像这样(这不起作用)： df = []
items = range(50)
def try_my_operation(item):
if i <= 10:
df.append(i)
else:
df.append(i+1000)
executor = concurrent.future
浏览 8提问于2020-04-08得票数 0
1回答
我有两个端点：/parent和/child/{parentId}都将返回List
让我们假设每次调用都需要两秒钟。因此，如果我调用/parent并在列表中获得10个父级，并且我想调用并填充每个子级，我总共需要22秒( /parent需要2秒，10倍于/child/{parentId}，每个2秒)
在Spring和Java10中，我可以结合使用Future和RestTemplate来进行异步调用。
在这段代码中，/slow-five是对父级调用，而/slow-six是对子级调用。
public List<Child> runSlow2() {
ExecutorService
浏览 2提问于2018-12-14得票数 0
1回答
我有一个类，在这个类中我实例化了一个Keras模型来执行预测。这个类的组织方式如下：
class MyClass():
def __init__(self):
self.model = None
def load(path):
self.model = tf.keras.models.load_model(path_)
def inference(data):
#...
pred = self.model.predict(data)
#...
浏览 5提问于2021-09-30得票数 2
我正在截取几千个网页与pyppeteer。我偶然发现，在两个开放的终端上运行相同的脚本会使我获得的输出翻倍。我通过打开多达6个终端并运行脚本来测试这一点，并且我能够获得6倍的性能。
我正在考虑使用loop.run_in_executor在主程序的多个进程或线程中运行脚本。
这是正确的调用，还是在我的脚本中达到了IO/CPU限制？
我是这么想的。我不知道这是不是应该做的事。
import asyncio
import concurrent.futures
async def blocking_io():
# File operations (such as logging) can b
浏览 0提问于2019-06-07得票数 2
这是一个关于和线程安全的问题。
作为一个简化的例子，请考虑这个类：
@Builder
public class Avengers {
@Singular
private List<String> members;
}
这会生成一个构建器，在这里我可以这样做：
final Avengers team = Avengers.builder()
.member("Iron Man")
.member("Thor")
.member("Captain America")
.build();
Sy
浏览 14提问于2022-06-10得票数 1
回答已采纳
我有以下经过简化的代码：
import concurrent.futures
pool = concurrent.futures.ThreadPoolExecutor(8)
def _exec(x):
return x + x
myfuturelist = pool.map(_exec,[x for x in range(5)])
# How do I wait for my futures to finish?
for result in myfuturelist:
# Is this how it's done?
print(result)
#.
浏览 2提问于2018-01-31得票数 7
回答已采纳
1回答
下面的代码实际上只允许并行执行类似于(函数(范围n))的内容。
(experiment-with-agents 10000 10 #(filter prime? %))
例如，用10个代理查找0到10000之间的素数。
(experiment-with-futures 10000 10 #(filter prime? %))
期货也是一样。
现在的问题是，期货的解决方案不会因为更多的期货而运行得更快。示例：
; Futures
(time (experiment-with-futures 10000 1 #(filter prime? %)))
"Elapsed time: 33417
浏览 2提问于2014-09-16得票数 2
回答已采纳
我有一个列表，说有登录名，基于列表内容，我正在处理其他方法，如：
while ( it.hasNext() )
{
method1();
}
而不是等待顺序，因为这些任务是独立的，我想并行运行它们。
我做了以下工作：
ExecutorService service = Executors.newFixedThreadPool(5);
final List<Future<?>> futures = new ArrayList<>();
while ( it.hasNext() )
{
Future<?> fut
浏览 1提问于2019-09-28得票数 1
我有多个可完成的未来，如：
CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> xxx);
CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> xxx);
List<CompletableFuture<Void>> futures = Lists.newArrayList(future1, future2);
当我在下面运行时，这两个未来的任务是否并行运行？异常会抛出一个未
浏览 0提问于2020-02-24得票数 2
回答已采纳
4回答
使循环多线程，Java很昂贵
、、、、
我想使用Java的ExecutorService和Future类来解决问题。目前，我正在从一个非常昂贵的函数中提取许多样本，使用for循环计算(每个示例可能需要几分钟)。我有一个类FunctionEvaluator，它为我计算这个函数，而且这个类实例化非常昂贵，因为它包含大量的内部内存，所以我让这个类很容易用一些内部计数器和一个reset()方法重用。我现在的情况是这样的：
int numSamples = 100;
int amountOfData = 1000000;
double[] data = new double[amountOfData];//Data comes from so
浏览 1提问于2018-06-21得票数 3
回答已采纳
在CompletableFuture.supplyAsync()的生产环境中发现了一个问题，我们有一个批处理方法，如下所示：
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
public class CompletableFutureProblem {
public voi
浏览 5提问于2020-11-21得票数 3
回答已采纳
我刚刚开始使用Python3中的库concurrent.futures对一系列图像应用一些函数，以便处理这些图像并对它们进行整形。函数是resize(height, width)和opacity(number)。
另一方面，我使用images()函数来生成类似文件的对象，所以我尝试使用以下代码来并行处理图像：
import concurrent.futures
From mainfile import images
From mainfile import shape
def parallel_image_processing :
with concurrent.futures.Threa
浏览 0提问于2014-09-04得票数 0
对于使用并发性，我感到困惑的是什么时候应该使用不同的python并发库。据我理解，多线程、多线程和异步编程是并发性的一部分，而multiprocessing是称为并行性的并发子集的一部分。
我在web上搜索了在python中实现并发的不同方法，并遇到了多处理库concurrenct.futures‘ProcessPoolExecutor()和ThreadPoolExecutor()和异步。让我困惑的是这些图书馆之间的区别。特别是多进程库所做的工作，因为它有像pool.apply_async这样的方法，它也做异步的工作吗？如果是这样的话，为什么在实现异步并发(多进程与协作多任务处理)的方法不同时
浏览 8提问于2020-04-21得票数 36
回答已采纳
我尝试执行asynchronous requests，如下所示：
# Example 2: asynchronous requests
import asyncio
import aiohttp
import time
import concurrent.futures
no = int(input("time of per "))
num_requests = int(input("enter the no of threads "))
no_1 = no
avg = 0
async def fetch():
async with aiohttp.C
浏览 0提问于2018-02-14得票数 4
回答已采纳
我正在遵循ray文档中的教程。
具体到这一部分：
client = serve.start()
config = {"num_replicas": 3}
client.create_backend("tf:v1", TFMnistModel, TRAINED_MODEL_PATH,config=config)
client.create_endpoint("tf_classifier", backend="tf:v1", route="/mnist")
下面将单个示例发送到后端
sample_data= np.ra
浏览 6提问于2021-02-25得票数 1
回答已采纳
1回答
我购买了在Google上访问e2-highmem-16 (16个vCPU，128 GB内存)的机器类型，因为我需要运行大量计算成本高昂的代码。
我使用了Mac中的ssh，并在conda和我需要的所有包中安装了python，我可以运行代码。唯一的问题是，代码在VM上的运行速度几乎比在我的计算机上慢。根据计算引擎统计，我只使用了0.03%的CPU。这就是为什么它这么慢吗？如果是这样，我如何使用100%的CPU？
浏览 3提问于2020-07-04得票数 0
回答已采纳
在阅读Ray 时，我发现它本身就支持dicts的序列化(“直接序列化”)，但我不明白这是什么意思，或者我应该如何使用这些序列化的对象。
假设我有以下流程：
import ray
ray.init()
dict_1 = {}
dict_2 = {}
@ray.remote
def f(x):
dict_1[x] = x*x
dict_2[x] = x*x*x
return x
futures = [f.remote(i) for i in range(4)]
print(ray.get(futures))
我应该做些什么来保护线程安全的行为吗？
浏览 0提问于2020-04-22得票数 0
我正在玩concurrent.futures.ThreadPoolExecutor，看我是否能从我的四核处理器(有8个逻辑核)中挤出更多的工作。因此，我编写了以下代码：
from concurrent import futures
def square(n):
return n**2
def threadWorker(t):
n, d = t
if n not in d:
d[n] = square(n)
def master(n, numthreads):
d = {}
with futures.ThreadPoolExecuto
浏览 9提问于2014-01-18得票数 9
回答已采纳
1回答
并行运行Flair嵌入
、、、、
我有一个列表，其中包含了数以百万计的句子，我需要嵌入。我正为此目的使用。这个问题似乎应该是令人尴尬的平行问题。但是当我试图优化的时候，我要么没有提高性能，要么它就停下来了。
我将我的句子定义为一个简单的字符串列表：
texts = [
"this is a test",
"to see how well",
"this system works",
"here are alot of words",
"many of them",
"they keep com
浏览 10提问于2022-08-30得票数 3
此代码(snippet_1)是从改编而来的
import concurrent.futures
import urllib.request
URLS = ['http://www.foxnews.com/',
'http://www.cnn.com/',
'http://europe.wsj.com/',
'http://www.bbc.co.uk/']
# Retrieve a single page and report the URL and contents
def lo
浏览 0提问于2019-08-17得票数 1
回答已采纳
3回答
如何在Java (不是Java或Spring)中使用事务管理器(如、或)来支持以下用例：
让我们假设我们有以下类：
public class Dao {
public void updateDatabase(DB db) {
connet to db
run a sql
}
}
然后我们创建一个Java Runnable，如下所示：
public class MyRunnable extends Runnable {
Dao dao;
DB db;
public MyRunnable(Dao dao, DB db)
浏览 2提问于2011-03-12得票数 4
回答已采纳
1回答
我正在使用Pandas0.18/Python3.5在英特尔i3 (四个核)上编写代码。
我读过这样的文章：
我还做了一些工作，即IO绑定(将CSV文件解析为dataframes)。我需要做大量的计算，主要是将数据乘以。
我的代码目前是使用concurrent.futures ThreadPoolExecutor并行的。
我的问题是：
一般来说，我应该使用线程并行运行熊猫作业，还是熊猫可以有效地利用所有核心，而不需要我明确告诉它呢？(在这种情况下，我将依次执行我的作业)。
浏览 4提问于2016-09-15得票数 4
回答已采纳
1回答
上面有很多关于asyncio的帖子，问了很多关于asyncio的具体问题，但我不能掌握在特定情况下使用什么的正确方法。 假设我想并行解析和爬行多个网页。我可以通过至少3种不同的方法来使用asyncio： 使用pool.submit with ThreadPoolExecutor(max_workers=10) as pool:
result_futures = list(map(lambda x: pool.submit(my_func, x), my_list))
for future in as_completed(result_futures):
res
浏览 25提问于2021-06-28得票数 0
回答已采纳
1回答
我对ray很陌生，我正在尝试并行化我开发的模拟器。这里有一个我的模拟器的例子，它显然更复杂。
import some_library
import sim_library_with_global_object
class Model(object):
def __init__(self,init_vals):
#initialize object using some of the global_object from sim_library.
#the Model object have it's own variables not glob
浏览 3提问于2020-11-08得票数 2
我正在尝试使用std：：异步来填充一个向量。其背后的想法是使用多线程来节省时间。但是，运行一些基准测试，我发现我的非异步方法更快！
#include <algorithm>
#include <vector>
#include <future>
std::vector<int> Generate(int i)
{
std::vector<int> v;
for (int j = i; j < i + 10; ++j)
{
v.push_back(j);
}
return
浏览 1提问于2019-08-27得票数 0
我将resnet50 TensorFlow模型转换为TensorRT引擎。当我运行推断时，它只使用我的一个GPU。我有两个RTX3090图形处理器。如何在多个GPU上运行推理？
浏览 9提问于2022-01-31得票数 0
2回答
假设我有scrapper_1.py，scrapper_2.py，scrapper_3.py。
我现在运行它的方式是从pycharm中分别运行/执行，这样我就可以在任务管理器中看到执行中的3个python.exe。
现在，我正在尝试编写一个主脚本，比如scrapper_runner.py，它将这个剪贴器作为模块导入，然后并行运行，而不是按顺序运行。
我尝试用子进程、多进程甚至来自不同SO帖子的os.system的例子……但如果没有任何运气..。从日志中，它们都是按顺序运行的，而从任务管理器中，我只看到一次python.exe执行。
这是这种过程的正确模式吗？
编辑:1(尝试使用concurren
浏览 51提问于2018-10-15得票数 0
回答已采纳
我正在学习scala中的Future monad。我写了以下代码： object MultipleFutures extends App {
// (a) create three futures
val aaplFuture = getStockPrice("AAPL")
val amznFuture = getStockPrice("AMZN")
val googFuture = getStockPrice("GOOG")
def sleep(time: Long): Unit = Thread.sleep(time
浏览 28提问于2020-10-07得票数 0
回答已采纳
我试图通过在concurrent.futures库的ThreadPoolExecutor中运行我的http请求来加速web抓取。 代码如下： import concurrent.futures
import requests
from bs4 import BeautifulSoup
urls = [
'https://www.interactivebrokers.eu/en/index.php?f=41295&exch=ibfxcfd&showcategories=CFD',
'https://www.intera
浏览 11提问于2020-12-09得票数 1
回答已采纳
1回答
我试图使用concurrent.futures异步地从AWS DynamoDB检索项，以缩短函数时间。
def retrieve_dynamo_item(dynamo_tablename, key):
dynamodb = boto3.resource('dynamodb')
dynamo_table = dynamodb.Table(dynamo_tablename)
dynamo_result = dynamo_table.get_item(Key=key)
return dynamo_result.get('Item')
浏览 8提问于2021-06-16得票数 0
回答已采纳
2回答
在中，我读到，理想情况下，您应该为每个应用程序创建一个ClientSession。我怀疑这应该是类似于“每个线程创建一个ClientSession”(我使用的是Python3x)。
import aiohttp
import asyncio
async def get_it_async(url: str, session):
async with session.get(url) as resp:
print(resp.status)
print(len(await resp.text()))
def run_it(fn, *args, **kwar
浏览 0提问于2020-07-03得票数 1
3回答
我希望迭代元素列表，并异步(以并行方式)执行对它们的操作。
这是我的代码：
@Autowired
ElemManager elemManager;
...
List<Elem> elems = new ArrayList<>();
for ( Elem elem : elems ) {
System.out.println(elemManager.doSomething(elem).get());
}
其中ElemManager是：
public class ElemManager {
@Async
public Future<Strin
浏览 0提问于2016-07-11得票数 4
回答已采纳
假设我有两个服务调用，我想并行运行它们。现在代码很简单，就像
a.service1()
b.service2()
我使用callable接口来并行运行这个进程。
List callables = newArrayList();
callables.add(new Callable() {
public Object call() throws Exception {
a.service1();
}
});
callables.add(new Callable() {
public Object call() throws Exception {
b.ser
浏览 1提问于2014-09-24得票数 0
我在aws lambda中有下面的代码可以从API获得响应，直到状态完成为止。我使用了来自concurrent.futures的concurrent.futures。
这是示例代码。
import requests
import json
import concurrent.futures
def copy_url(headers,data):
collectionStatus = 'INITIATED'
retries = 0
print(" The data to be copied is ",data)
while (collec
浏览 2提问于2020-01-30得票数 3
1回答
我正在试图收回股票价格，并处理价格，因为他们来了。我是并发的初学者，但我认为这种设置似乎适合异步生产者-消费者模型，在这种模型中，每个生产者检索一个股票价格，并将其传递给消费者。现在，由于工作是CPU密集型的，消费者已经并行(多处理)进行了股票价格处理。因此，我已经有多个使用者在工作，而不是所有的生产者都完成了数据的检索。此外，我还想实施一个步骤，如果消费者发现它正在进行的股票价格是无效的，我们将为该股票生成一个新的消费者工作。
到目前为止，我有下面的玩具代码，它可以让我达到目的，但是我的process_data函数(消费者)有问题。
from concurrent.futures impor
浏览 4提问于2021-01-26得票数 1
回答已采纳
在并行处理项目列表时，Futures (vs并行集合)的复杂性增加有什么充分的理由吗？
List(...).par.foreach(x=>longRunningAction(x))
vs
Future.traverse(List(...)) (x=>Future(longRunningAction(x)))
浏览 0提问于2013-01-08得票数 15
回答已采纳
我正在一个基于Intel i3的机器上运行以下代码，该机器有4个虚拟核(2个超级线程/物理内核，64位)，并安装了Ubuntu14.04：
n = multiprocessing.cpu_count()
executor = ThreadPoolExecutor(n)
tuple_mapper = lambda i: (i, func(i))
results = dict(executor.map(tuple_mapper, range(10)))
代码似乎不是以并行方式执行的，因为CPU的利用率一直只有25%。在利用率图上，一次只使用四个虚拟核中的一个。使用的核心每10秒左右交替一次。
但是
浏览 2提问于2015-05-21得票数 13
回答已采纳
1回答
我有一个Spark应用程序选择一个子集并对该子集执行一些操作。每个子集和它的操作之间没有依赖和交互，所以我尝试使用多线程来让它们并行运行，以提高性能。代码如下： Dataset<Row> fullData = sparkSession.read().json("some_path");
ExecutorService executor = Executors.newFixedThreadPool(10);
List<Runnable> tasks = Lists.newArrayList();
for (int i = 1; i <= 50; i
浏览 16提问于2019-06-16得票数 0
回答已采纳
1回答
我正试图使用S3从requests_futures上下载大约3,000个文件(每个文件可能有3 MB大小)，但是下载速度在大约900后下降很慢，并且实际上比基本的for-循环运行得慢。
我似乎没有耗尽内存或CPU带宽。然而，它看起来像是我机器上的Wifi连接速度几乎为零:我从几千个数据包/秒下降到只有3-4个包。最奇怪的是，在Python进程退出并重新启动wifi适配器之前，我无法加载任何网站。
究竟是什么原因造成了这种情况，我如何去调试它呢？
如果有帮助，下面是我的Python代码：
import requests
from requests_futures.sessions import
浏览 3提问于2016-10-27得票数 5
2回答
我有一个包含n h5文件的目录，每个目录都有要过滤的m图像堆栈。对于每幅图像，我将使用dask并行阵列运行滤波(高斯和拉普拉斯)，以加快处理速度()。我将通过apply_parallel()函数在scikit-映像中使用dask数组。
我将使用20 cpus在小型服务器上运行处理。
--我想得到一个建议，建议使用哪种并行策略更有意义：
1) h5文件的顺序处理和用于dask处理的所有cpus
2)用h5内核并行处理x文件，并使用剩余的20-x进行dask处理。
3)对h5文件、h5文件中的图像以及dask的剩余资源进行分配和并行处理。
谢谢你的帮助！
浏览 6提问于2016-02-10得票数 2
回答已采纳
我正在实现一个python模块，它使用一个包含三个列表(x、y、val)的元组，并根据给定的比率对它们进行子采样。我这样做对吗？
是否异步写入磁盘？
我能让许多生产者和消费者都生成数据并将数据写入同一个输出文件吗？
当我将此代码与单个线程的简单实现进行比较时，它们对其运行时执行类似的操作。
import bisect
import numpy as np
import gzip
import asyncio
class SignalPDF:
def __init__(self, inputSignal):
self.x = inp
浏览 1提问于2020-01-17得票数 2
我正在尝试在一个运行在raspberry pi 3 (4核)上的股票价格机器学习应用程序中使用多进程。下面是说明这个问题的一些代码：
from concurrent import futures
def some_function(x):
return x + 1
def main_function(some_list):
with futures.ProcessPoolExecutor() as executor:
results = executor.map(some_function, some_list)
return results
if
浏览 0提问于2016-11-28得票数 0
我有一个rest api控制器，它接收一个巨大的元素集合，在数据库中搜索每个元素，更新字段，然后保存更新的对象。数据库响应非常慢，所以我想使用某种异步调用。我的代码：
@RequestMapping(value = "qwerty/", method = RequestMethod.POST,
consumes = {"application/xml"},
produces = "application/xml")
@ResponseBody
public PriceResponce
浏览 34提问于2018-01-07得票数 0
回答已采纳
我有以下async函数(实现并不重要)：
async fn long_task(task_number: i32) {
// do some long work
println!("Task {} executed", task_number);
}
我想同时运行这个函数n次，所以我定义了这个函数：
async fn execute_long_tasks_async(n: i32) {
let mut futures = Vec::new();
for i in 1..=n {
futures.push(long_task(i))
浏览 3提问于2020-09-05得票数 4
2回答
如何实现并行硒处理
、、、、
我之前问过这个问题，现在已经删除了，但没有正确表达。我正在努力改善这一点。
任何帮助都将不胜感激。
我要做的：自动化某些任务
anythingrefresh 转到网站搜索任务，如果找到，打开新选项卡中的任务(切换到新选项卡-tab1)单击“查看”，然后关闭选项卡(关闭-切换到tab0) --这不会返回第一个选项卡(tab0)，因此“查看”会自动更新(我认为这是通过会话/缓存实现的)--有一个侧列显示所有看到的任务。和在所有任务(tab0)的末尾，单击返回预定代码的“已完成任务”。<code>F 214</code>
我正在运行的内容：
class SomeClass(S
浏览 3提问于2021-06-24得票数 0
回答已采纳
我想让我的类方法并行运行，但它只会产生某种我无法解决的错误。我的代码是：
import concurrent.futures as futures
samples = ['asfd', 'zxcv', 'asf', 'qwer']
class test:
def __init__(self, samples):
maturedb = {}
with futures.ProcessPoolExecutor() as exe:
for samplename, dRes
浏览 1提问于2013-07-02得票数 10
我试图使用多线程和/或多重处理来在某种程度上加快我的脚本速度。本质上，我有一个从CSV中读取的10,000个子网的列表，我想将这些子网转换成IPv4对象，然后存储在数组中。
我的基本代码如下所示，并在大约300 is内执行：
aclsConverted = []
def convertToIP(ip):
aclsConverted.append(ipaddress.ip_network(ip))
for y in acls:
convertToIP(y['srcSubnet'])
如果我尝试使用concurrent.futures线程，它可以工作，但速度是3-
浏览 1提问于2019-11-06得票数 6
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
