Question

所以我有一个我正在编写的算法，并且函数multiprocess应该在与cpus并行的多个进程上调用另一个函数CreateMatrixMp()。我以前从未做过多处理，也不能确定以下哪种方法更有效。这个词＆＃34;高效＆＃34;在函数CreateMatrixMp()的上下文中使用需要被调用数千次。我已经阅读了python multiprocessing模块的所有文档，并且已经实现了这两种可能性：

首先使用Pool类：

def MatrixHelper(self, args):
    return self.CreateMatrix(*args)

def Multiprocess(self, sigmaI, sigmaX):

    cpus = mp.cpu_count()
    print('Number of cpu\'s to process WM: %d' % cpus)
    poolCount = cpus*2
    args = [(sigmaI, sigmaX, i) for i in range(self.numPixels)]

    pool = mp.Pool(processes = poolCount, maxtasksperchild= 2)
    tempData = pool.map(self.MatrixHelper, args)
    pool.close()
    pool.join()

接下来是使用Process类：

def Multiprocess(self, sigmaI, sigmaX):

    cpus = mp.cpu_count()
    print('Number of cpu\'s to process WM: %d' % cpus)

    processes = [mp.Process(target = self.CreateMatrixMp, args = (sigmaI, sigmaX, i,)) for i in range(self.numPixels)]
    for p in processes:
        p.start()
    for p in processes:
        p.join()

Pool似乎是更好的选择。我读过它会减少开销。并且Process不考虑机器上的cpu数量。唯一的问题是以这种方式使用Pool会在出错后给出错误，每当我修复错误时，它下面会有一个新错误。 Process似乎更容易实现，而且据我所知，它可能是更好的选择。您的经验告诉您什么？

如果应该使用Pool，那么我选择map()是对的吗？最好保持订单。我有tempData = pool.map(...)因为map函数应该返回每个进程的结果列表。我不确定Process如何处理其返回的数据。

Answer 1

我认为Pool类通常更方便，但这取决于您是希望结果是有序的还是无序的。

假设您要创建4个随机字符串（例如，可能是随机用户ID生成器等）：

import multiprocessing as mp
import random
import string

# Define an output queue
output = mp.Queue()

# define a example function
def rand_string(length, output):
    """ Generates a random string of numbers, lower- and uppercase chars. """
    rand_str = ''.join(random.choice(
                    string.ascii_lowercase
                    + string.ascii_uppercase
                    + string.digits)
               for i in range(length))
    output.put(rand_str)

# Setup a list of processes that we want to run
processes = [mp.Process(target=rand_string, args=(5, output)) for x in range(4)]

# Run processes
for p in processes:
    p.start()

# Exit the completed processes
for p in processes:
    p.join()

# Get process results from the output queue
results = [output.get() for p in processes]

print(results)

# Output
# ['yzQfA', 'PQpqM', 'SHZYV', 'PSNkD']

在这里，顺序可能并不重要。我不确定是否有更好的方法，但如果我想按照调用函数的顺序跟踪结果，我通常会返回带有ID作为第一项的元组，例如

# define a example function
def rand_string(length, pos, output):
    """ Generates a random string of numbers, lower- and uppercase chars. """
    rand_str = ''.join(random.choice(
                    string.ascii_lowercase
                    + string.ascii_uppercase
                    + string.digits)
                for i in range(length))
    output.put((pos, rand_str))

# Setup a list of processes that we want to run
processes = [mp.Process(target=rand_string, args=(5, x, output)) for x in range(4)]

print(processes)

# Output
# [(1, '5lUya'), (3, 'QQvLr'), (0, 'KAQo6'), (2, 'nj6Q0')]

这让我对结果进行排序：

results.sort()
results = [r[1] for r in results]
print(results)

# Output:
# ['KAQo6', '5lUya', 'nj6Q0', 'QQvLr']

Pool类

现在问你的问题：这与Pool课程有什么不同？您通常更喜欢Pool.map返回有序的结果列表，而无需通过创建元组和按ID排序。因此，我认为它通常更有效率。

def cube(x):
    return x**3

pool = mp.Pool(processes=4)
results = pool.map(cube, range(1,7))
print(results)

# output:
# [1, 8, 27, 64, 125, 216]

同样地，还有一个＆＃34; apply＆＃34;方法：

pool = mp.Pool(processes=4)
results = [pool.apply(cube, args=(x,)) for x in range(1,7)]
print(results)

# output:
# [1, 8, 27, 64, 125, 216]

Pool.apply和Pool.map都会锁定主程序，直到进程完成。

现在，您还拥有Pool.apply_async和Pool.map_async，它们会在流程完成后立即返回结果，这与上面的Process类基本相似。优势可能是它们为您提供了方便的apply和map功能，您可以从Python的内置apply和map

中了解这些功能。

Answer 2

您可以使用pypeln轻松地做到这一点：

import pypeln as pl

stage = pl.process.map(
    CreateMatrixMp, 
    range(self.numPixels), 
    workers=poolCount, 
    maxsize=2,
)

# iterate over it in the main process
for x in stage:
   # code

# or convert it to a list
data = list(stage)

Python多处理：如何知道使用池或进程？

2 个答案:

Pool类