如何使用jQuery或纯JavaScript将用户从一个页面重定向到另一个页面？

在下面的示例代码中,我想恢复函数的返回值worker.我该怎么做呢？这个值存储在哪里？

示例代码:

import multiprocessing

def worker(procnum):
    '''worker function'''
    print str(procnum) + ' represent!'
    return procnum


if __name__ == '__main__':
    jobs = []
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(i,))
        jobs.append(p)
        p.start()

    for proc in jobs:
        proc.join()
    print jobs

输出:

0 represent!
1 represent!
2 represent!
3 represent!
4 represent!
[<Process(Process-1, stopped)>, <Process(Process-2, stopped)>, <Process(Process-3, stopped)>, <Process(Process-4, stopped)>, <Process(Process-5, stopped)>]

我似乎无法在存储的对象中找到相关属性jobs.

提前谢谢,blz

如果我有一个带有2个处理器的池对象,例如:

p=multiprocessing.Pool(2)

我想迭代目录上的文件列表并使用map函数

有人可以解释这个函数的chunksize是什么:

p.map(func, iterable[, chunksize])

如果我将chunksize设置为10,那意味着每10个文件应该用一个处理器处理吗？

当你map可以迭代到a multiprocessing.Pool时,迭代被划分为一开始池中每个进程的队列,或者是否有一个公共队列,当进程空闲时从中获取任务？

    def generate_stuff():
        for foo in range(100):
             yield foo

    def process(moo):
        print moo

    pool = multiprocessing.Pool()
    pool.map(func=process, iterable=generate_stuff())
    pool.close()

所以考虑到这个未经测试的建议代码; 如果池中有4个进程,每个进程都会分配25个要做的事情,或者100个进程被进程逐个挑选,寻找要做的事情,以便每个进程可以执行不同数量的东西,例如30 ,26,24,20.

我在类中有一个方法，该方法需要循环执行大量工作，我想将工作分散到我的所有核心上。

我编写了以下代码，如果我使用normal map，则可以使用，但是pool.map返回错误。

import multiprocessing
pool = multiprocessing.Pool(multiprocessing.cpu_count() - 1)

class OtherClass:
  def run(sentence, graph):
    return False

class SomeClass:
  def __init__(self):
    self.sentences = [["Some string"]]
    self.graphs = ["string"]

  def some_method(self):
      other = OtherClass()

      def single(params):
          sentences, graph = params
          return [other.run(sentence, graph) for sentence in sentences]

      return list(pool.map(single, zip(self.sentences, self.graphs)))


SomeClass().some_method()

错误：

AttributeError：无法腌制本地对象“ SomeClass.some_method..single”

为什么不能泡菜single？我什至尝试移动single到全局模块范围（不在类内部-使其独立于上下文）：

import multiprocessing
pool = multiprocessing.Pool(multiprocessing.cpu_count() - 1)

class OtherClass:
  def run(sentence, graph):
    return False


def single(params):
    other = …

使用 Python 的多处理，在Pool其中包含一堆ThreadPools是否有意义？说我有这样的事情：

def task(path):
  # i/o bound
  image = load(path)
  # cpu bound but only takes up 1/10 of the time of the i/o bound stuff
  image = preprocess(img)
  # i/o bound
  save(image, path)

然后我想处理一个路径列表path_list。如果我使用，ThreadPool我仍然会因为 cpu 绑定位而达到天花板。如果我使用 a ，Pool我会花太多时间等待 i/o。那么最好将path_list多个进程拆分为每个进程使用多个线程吗？

重申我的示例的另一种更简短的方法是，如果我有一个方法应该是多线程的，因为它是 i/o 绑定的，但我也想使用许多 cpu 内核怎么办？如果我使用 a，Pool我会将每个核心用于 I/O 绑定的单个任务。如果我使用一个，ThreadPool我只能使用一个核心。

我一直在涉足 Python 的多处理库，虽然它提供了一个非常容易使用的 API，但它的文档并不总是很清楚。特别是，我发现传递给 Pool 类实例的参数“maxtasksperchild”非常令人困惑。

以下内容直接来自 Python 的文档 (3.7.2)：

maxtasksperchild是工作进程在退出并被新工作进程替换之前可以完成的任务数，以释放未使用的资源。默认的 maxtasksperchild 是 None，这意味着工作进程将与池一样长。

以上对我提出的问题比它回答的要多。工作进程与池一样长是否有害？是什么让工作进程“新鲜”，什么时候需要？一般来说，什么时候应该明确设置 maxtasksperchild 的值而不是让它默认为“无”，以及为了最大化处理速度而被认为是最佳实践？

从@Darkonaut 关于 chunksize 的惊人答案中，我现在了解了 chunksize 的作用和代表。由于为 chunksize 提供值会影响“任务”的数量，我想知道是否应该考虑它们的依赖性以确保最大性能？

谢谢！

如何找到multiprocessing.Pool实例的最佳块大小？

之前我用过这个来创建一个nsudoku对象的生成器:

processes = multiprocessing.cpu_count()
worker_pool = multiprocessing.Pool(processes)
sudokus = worker_pool.imap_unordered(create_sudoku, range(n), n // processes + 1)

为了测量时间,我time.time()在上面的片段之前使用,然后按照描述初始化池,然后我将生成器转换为list(list(sudokus))以触发生成项目(仅用于时间测量,我知道这在最终程序中是无意义的),然后我time.time()再次使用时间并输出差异.

我观察到每个对象的块大小n // processes + 1约为0.425毫秒.但我也观察到CPU只在整个过程的前半部分完全加载,最终使用率下降到25%(在具有2核和超线程的i3上).

如果我使用较小的块大小int(l // (processes**2) + 1),我会得到大约0.355毫秒的时间,并且CPU负载分布更好.它只有一些小的尖峰到ca. 75%,但在处理时间的长时间内保持高位,然后降至25%.

是否有更好的公式来计算块大小或更好的方法来使用CPU最有效？请帮助我提高这个多处理池的有效性.

我一直在使用Python的多处理模块分析一些代码('job'函数只是对数字进行平方).

data = range(100000000)
n=4
time1 = time.time()
processes = multiprocessing.Pool(processes=n)
results_list = processes.map(func=job, iterable=data, chunksize=10000)
processes.close()
time2 = time.time()
print(time2-time1)
print(results_list[0:10])

我发现奇怪的一件事是最佳的chunksize似乎是大约10k元素 - 这在我的计算机上花了16秒.如果我将chunksize增加到100k或200k,那么它会减慢到20秒.

这种差异可能是由于长时间列表中酸洗所需的时间更长吗？100个元素的块大小需要62秒,我假设是由于在不同进程之间来回传递块所需的额外时间.

假设我有一组 20 个 CPU 繁重的任务（每个任务约 1 小时，但有些需要更长的时间），它们是通过调用函数来运行的，例如Pool.apply_async(function, task_list)等。PC 有 12 个内核。所以我可以分散负载，并使用所有 12 个内核。

每个任务的结果可能需要运行一个新任务（某些任务可能需要 1 次新运行，其他可能需要 10 次）。

当需要新任务时，我想将该任务生成到现有池中task_list，以始终充分优化 CPU 使用率。

目前我运行了 20 个任务，等待完成，启动新的 ~18 个任务，等待完成，启动剩余的新任务，......，而它恰好只有 1 个核心被使用了一个小时，而不是 12 个。这导致计算时间损失了几小时到几天。我可以在同一个工作人员中运行更新的任务，但这会导致更大的损失）

使用池似乎不可能在池启动时向池中添加更多任务。这是正确的，还是有一些聪明的方法可以做到这一点，而我在四处搜索时却错过了？

（我看到的唯一选项是使用process而不是pool，并在动态列表上进行 while 循环，该列表将典型任务作为单个进程启动，同时只允许最多 12 个进程同时运行，并且对于每个任务，或新的任务，将它们放在动态列表中，并在将任务发送到进程时将其删除。）

我尝试利用python的池多处理功能。

与我如何设置块大小无关（在Windows 7和Ubuntu下-后者在下面具有4个内核），并行线程的数量似乎保持不变。

from multiprocessing import Pool
from multiprocessing import cpu_count
import multiprocessing
import time


def f(x):
    print("ready to sleep", x, multiprocessing.current_process())
    time.sleep(20)
    print("slept with:", x, multiprocessing.current_process())


if __name__ == '__main__':
    processes = cpu_count()
    print('-' * 20)
    print('Utilizing %d cores' % processes)
    print('-' * 20)
    pool = Pool(processes)
    myList = []
    runner = 0
    while runner < 40:
        myList.append(runner)
        runner += 1
    print("len(myList):", len(myList))

    # chunksize = int(len(myList) / processes)
    # chunksize = processes
    chunksize = 1
    print("chunksize:", chunksize)
    pool.map(f, …

除了一种情况外，我很享受 Polars 比 Pandas 的显着加速。我是 Polars 的新手，所以这可能只是我的错误用法。无论如何，这里是玩具示例：在单列上，我需要在我的情况下应用自定义函数，它来自parse库probablypeople（https://github.com/datamade/probablepeople），但问题是通用的。

Plain pandasapply与 Polars 具有相似的运行时间，但是带有parallel_applyfrom ( https://github.com/nalepae/pandaralel ) 的 pandas 的加速与核心数量成正比。

在我看来，Polars 仅使用单核来实现自定义功能，或者我错过了什么？

如果我正确使用 Polars，也许有可能创建像pandaralellPolars 这样的工具？

!pip install probablepeople
!pip install pandarallel

import pandas as pd
import probablepeople as pp
import polars as pl
from pandarallel import pandarallel

AMOUNT = 1000_000
#Pandas:
df = pd.DataFrame({'a': ["Mr. Joe Smith"]})
df = df.loc[df.index.repeat(AMOUNT)].reset_index(drop=True)

df['b'] = df['a'].apply(pp.parse)

#Pandarallel:
pandarallel.initialize(progress_bar=True)
df['b_multi'] = df['a'].parallel_apply(pp.parse)

#Polars:
dfp = …

我是多处理概念的新手。

我的代码

from multiprocessing import Process
def square(x):
 
    for x in numbers:
        print('%s squared  is  %s' % (x, x**2))
 
if __name__ == '__main__':
    numbers = [43, 50, 5, 98, 34, 35]
 
    p = Process(target=square, args=('x',))
    p.start()
    p.join
    print "Done"
     

结果

Done
43 squared  is  1849
50 squared  is  2500
5 squared  is  25
98 squared  is  9604
34 squared  is  1156
35 squared  is  1225

我明白了，我们可以用来multiprocessing.cpu_count()获取系统中的CPU数量

然而，我未能实现两件感兴趣的事情。-

1. 将所有任务平均分配给所有CPU
2. 检查哪个CPU被哪个进程使用