我两天前才开始学习 javascript，所以我还是个新手。我已经编写了最佳代码，但需要 20 分钟才能运行。我想知道是否有一种简单的方法可以与 for 循环并行处理，例如

for (x=0; x<5; x++){ 处理器 1 执行 ...

for (x=5; x<10; x++){ 处理器 2 做 ...

在我python-flask在 port 运行的 Web 应用程序中5001，我有一个场景来创建一个端点，其中所有其他端点视图函数都需要并行执行，然后聚合所有单独的响应以在同一请求生命周期中返回它。

例如， routes在flaskapp包含以下view功能

@app.route(/amazon)
def amazon():
   return "amazon"

@app.route(/flipkart)
def flipkart():
   return "flipkart"

@app.route(/snapdeal)
def sd():
   return "snapdeal"

注：在上述三个端点中，network io涉及的金额较大

我正在创建另一个端点，即使在这里也必须集体调用所有其他端点实现。

### This is my endpoint
@app.route(/all)
def do_all():
   # execute all amazon, flipkart, snapdeal implementations

对于上述场景，我建议采用两种方法。

方法 1（多处理方法）：

将工作任务编写为单独的函数，通过python-multiprocessing模块调用每个调用者并收集响应

def do_all():
   def worker(name):
      # doing network io task for the given source name
      pass

   for name in ['amazon', 'flipkart', 'snapdeal']:
      p …

互斥锁是否全局锁定对变量的访问，或者仅锁定与锁定互斥锁相同范围内的变量的访问？

请注意，我必须更改这个问题的标题，因为很多答案似乎对我的问题感到困惑。这不是关于“互斥体对象”的范围（全局或其他）的问题，而是关于互斥体“锁定”变量的范围的问题。

我相信答案是互斥体锁定对所有变量的访问，即；所有全局和局部范围的变量。（这是互斥体阻塞线程执行而不是访问特定内存区域的结果。）

我正在尝试理解互斥体。

我试图了解互斥体将锁定内存的哪些部分，或者等效地，哪些变量。

然而，我从网上阅读的理解是，互斥体不会锁定内存，它们会锁定（或阻止）同时运行的线程，这些线程都是同一进程的成员。（那是对的吗？）

https://mortoray.com/2011/12/16/how-does-a-mutex-work-what-does-it-cost/

所以我的问题就变成了“互斥体是全局的吗？”

...或者它们可能“一般来说是全球性的，但 stackoverflow 社区可以想象一些特殊情况，但它们不是？”

最初考虑我的问题时，我对以下示例所示的内容感兴趣。

// both in global scope, this mutex will lock any global scope variable?
int global_variable;
mutex global_variable_mutex;

int main()
{
    // one thread operates here and locks global_variable_mutex
    // before reading/writing

    {
        // local variables in a loop
        // launch some threads here, and wait later
        int local_variable;
        mutex local_variable_mutex;
        // wait for launched thread to return

        // does the mutex here prevent data …

我正在寻找Python 的fork-join 模型的实现。作为 Java 的 ForkJoinPool，它应该允许将一个任务的工作递归地拆分（fork）为多个子任务。子任务完成后，结果将被连接并返回。理想情况下，它应该支持类似于concurrent.futures中的ThreadPoolExecutor和ProcessPoolExecutor的线程和进程，但目前线程更重要。它必须允许限制线程数量（我希望每个核心有一个线程）。我知道这只有在代码释放 GIL 时才有用。

维基百科的示例用于阐明 fork-join 模型：

solve(problem):
    if problem is small enough:
        solve problem directly (sequential algorithm)
    else:
        for part in subdivide(problem)
            fork subtask to solve(part)
        join all subtasks spawned in previous loop
        return combined results

Python中有这样的库吗？我找不到。

我有一个长时间运行的进程，它在数百万条记录之间执行匹配，我使用服务总线调用此代码，但是，当我的进程超过 5 分钟限制时，Azure 会再次从头开始处理已处理的记录。

我怎样才能避免这种情况

这是我的代码：

private static async Task ProcessMessagesAsync(Message message, CancellationToken token)
 {
   long receivedMessageTrasactionId = 0;
   try
   {
     IQueueClient queueClient = new QueueClient(serviceBusConnectionString, serviceBusQueueName, ReceiveMode.PeekLock);

     // Process the message
     receivedMessageTrasactionId = Convert.ToInt64(Encoding.UTF8.GetString(message.Body));

     // My Very Long Running Method
     await DataCleanse.PerformDataCleanse(receivedMessageTrasactionId);
            //Get Transaction and Metric details

     await queueClient.CompleteAsync(message.SystemProperties.LockToken);
   }
   catch (Exception ex)
   {
     Log4NetErrorLogger(ex);
     throw ex;
   }
}

我定义了一个运行 bash 脚本的 python 函数。假设该函数是：calc(x,y,z)。如果我在 python 中使用一些变量运行这个函数，

>>> calc(1,2,3)

它生成一个使用变量模拟某些内容的 C 代码(x=1, y=2, z=3)，编译 C 代码并执行编译后的输出文件。

我想在 jupyter 笔记本中同时运行多个calc(x,y,z)具有不同 s 的 s 。(x,y,z)您可能已经注意到，问题在于 jupyter Notebook 中的单元格是按顺序执行的。如果我运行三个calc函数，则需要比运行一个函数的时间长三倍的时间。

我尝试了两种方法，但效果不佳。

1. 使用multiprocessing模块：通过使用模块，可以calc在“一个单元”中同时执行多个操作。但为了以后的分析，我想同时执行多个单元，其中每个单元仅calc使用不同的处理器（或 CPU 内核）。

2. 使用ipyparallel细胞魔法（受此答案启发）：导入后我尝试如下ipyparallel

   # Cell 1
   %%px --targets 0 # use processor 0
   calc(1,1,1)
   

   Run Code Online (Sandbox Code Playgroud)

   。

   # Cell 2
   %%px --targets 1 # use processor 1
   calc(2,2,2)        
   

   Run Code Online (Sandbox Code Playgroud)

   。

   # Cell 3
   %%px …

   Run Code Online (Sandbox Code Playgroud)

我开始熟悉 JavaCompletableFuture组合，使用过 JavaScript 承诺。基本上，组合只是在指定的执行器上安排了链式命令。但是我不确定在执行组合时哪个线程正在运行。

假设我有两个执行者，executor1并且executor2；为简单起见，假设它们是单独的线程池。我安排了一个CompletableFuture（使用非常松散的描述）：

CompletableFuture<Foo> futureFoo = CompletableFuture.supplyAsync(this::getFoo, executor1);

然后，当做到这一点我转换Foo到Bar使用第二执行人：

CompletableFuture<Bar> futureBar .thenApplyAsync(this::fooToBar, executor2);

我知道getFoo()将从executor1线程池中的线程调用。我知道fooToBar()将从executor2线程池中的线程调用。

但是什么线程用于实际的组合，即在getFoo()完成和futureFoo()完成之后；但之前的fooToBar()命令被安排在executor2？换句话说，哪个线程实际运行代码以在第二个执行器上调度第二个命令？

调度是否作为executor1调用的同一线程的一部分执行getFoo()？如果是这样，这个可完成的未来组合是否等同于我fooToBar()在executor1任务的第一个命令中自己手动安排？