Question

我有一个python脚本，它并行运行一个方法。

parsers = {
    'parser1': parser1.process,
    'parser2': parser2.process
}

def process((key, value)):
    parsers[key](value)

pool = Pool(4)
pool.map(process_items, items)

process_items是我的方法，items是一个元组列表，每个元组都有两个元素。 items列表中有大约10万个项目。

然后

process_items将根据给定的参数调用方法。我的问题可能是70％的列表，我可以运行高并行性，但另外30％只能运行1/2线程，否则将导致我无法控制的失败。

所以在我的代码中，我有大约10个不同的解析器进程。比方说1-8我想用Pool（4）但9-10 Pool（2）运行。

优化此功能的最佳方法是什么？

Answer 1

我认为您最好的选择是在这里使用两个池：

from multiprocessing import Pool
# import parsers here

parsers = {
    'parser1': parser1.process,
    'parser2': parser2.process,
    'parser3': parser3.process,
    'parser4': parser4.process,
    'parser5': parser5.process,
    'parser6': parser6.process,
    'parser7': parser7.process,
}

# Sets that define which items can use high parallelism,
# and which must use low
high_par = {"parser1", "parser3", "parser4", "parser6", "parser7"}
low_par = {"parser2", "parser5"}

def process_items(key, value):
    parsers[key](value)

def run_pool(func, items, num_items, check_set):
    pool = Pool(num_items)
    out = pool.map(func, (item for item in items if item[0] in check_set))
    pool.close()
    pool.join()
    return out

if __name__ == "__main__":
    items = [('parser2', x), ...] # Your list of tuples
    # Process with high parallelism
    high_results = run_pool(process_items, items, 4, high_par)
    # Process with low parallelism
    low_results = run_pool(process_items, items, 2, low_par)

通过巧妙地使用同步原语，尝试在一个Pool中执行此操作是可能的，但我认为它看起来不会比这更清晰。它也可能最终运行效率较低，因为有时你的池需要等待工作完成，所以它可以处理一个低并行项，即使队列中有高并行性项目可用。

如果您需要以与原始迭代中相同的顺序获取每个process_items调用的结果，这会变得有点复杂，这意味着每个Pool的结果需要合并，但根据你的例子，我不认为这是一个要求。如果是的话请告诉我，我会相应地调整我的答案。

Answer 2

您可以在multiprocessing.Pool的构造函数中指定并行线程数：

from multiprocessing import Pool

def f(x):
    return x*x

if __name__ == '__main__':
    pool = Pool(5)   # 5 is the number of parallel threads
    print pool.map(f, [1, 2, 3])

如何更改并行进程数？

2 个答案: