Question

#!/usr/bin/env python

import multiprocessing

def tempx((the_time)):
    return int(the_time)*int(the_time)

def tempy((the_time, foobar)):
    return int(the_time)/(float(foobar))+100

def mp_handler():
    p = multiprocessing.Pool(2)
    foo = p.map(tempx, [('2')])
    print foo
    foo = p.map(tempy, [('100', '100000')])
    print foo
if __name__ == '__main__':
    mp_handler()

我有两种不同输入参数的方法。第一种方法仅包含：the_time，第二种方法只包含the_time and foobar

我需要特定顺序的结果，因此我使用了map函数。但是，上面的代码根本不使用多进程模块，因为我使用了两个map函数。我对吗？

最终目标是同时运行两个方法。

我在这里缺少什么？

达诺，这是我正在做的事情的一个例子

    import multiprocessing

def print_timing(func):
    def wrapper(*arg):
        t1 = time.time()
        res = func(*arg)
        t2 = time.time()
        print '%s took %0.3f ms' % (func.func_name, (t2-t1)*1000.0)
        return res
    return wrapper
@print_timing
def case_one(power_pred, power_core, num_thrs, possible_frequency, clamp_range):
    ds1_cur_freq = list()
    ds1_freq_index = list()
    ds1_cur_clamp = list()
    return ds1_cur_freq, ds1_freq_index, ds1_cur_clamp

@print_timing
def case_two(cpower_pred, power_core, num_thrs, possible_frequency, TT_index, DT_index, clamp_range):
    ds2_cur_freq = list()
    ds2_freq_index = list()
    ds2_cur_clamp = list()
    return ds2_cur_freq, ds2_freq_index, ds2_cur_clamp

def defs_finder():
    cpower_pred = list()
    power_pred = list()
    power_core = list()
    num_thrs = 3
    possible_frequency = list()
    clamp_range= list()
    DT_index =1
    TT_index = 0
    p = multiprocessing.Pool(2)
    #Case 1: DS1
#    ds1_cur_freq, ds1_freq_index, ds1_cur_clamp =
    ds1 = p.apply_async(case_one, args=(power_pred, power_core, num_thrs, possible_frequency))
    #Case 1: DS1
 #   ds1_cur_freq, ds1_freq_index, ds1_cur_clamp = case_one(power_pred, power_core, num_thrs, possible_frequency, clamp_range)
    #Case 2: DS2
#    ds2_cur_freq, ds2_freq_index, ds2_cur_clamp = case_two(cpower_pred, power_core, num_thrs, possible_frequency, TT_index, DT_index, clamp_range)
    ds2 = p.apply_async(case_two, args=(cpower_pred, power_core, num_thrs, possible_frequency, TT_index, DT_index))
    print ds1
    print ds2
    print ds1.get()
    print ds2.get()
#    ds1_cur_freq = ds1.get()[0]
#    ds1_freq_index = ds1.get()[1]
#    ds1_cur_clamp = ds1.get()[2]
#    ds2_cur_freq = ds2.get()[0]
#    ds2_freq_index = ds2.get()[1]
#    ds2_cur_clamp = ds2.get()[2]

defs_finder()

这就是现在实现的方式，并且会再现错误

Answer 1

如果您需要并行运行迭代的所有元素上的特定函数，并且阻塞直到整个迭代已被处理，则

Pool.map非常有用。在你的情况下，你只是在iterable中传递一个项目，所以你只是在子进程中运行一个函数，并阻塞直到它完成。这比在父进程中运行函数要慢，因为你有额外的IPC开销。

如果您的目标是仅使用一组参数同时运行tempx和tempy，Pool.apply_async是更好的选择：

import multiprocessing

def tempx(the_time):
    return int(the_time)*int(the_time)

def tempy(the_time, foobar):
    return int(the_time)/(float(foobar))+100

def mp_handler():
    p = multiprocessing.Pool(2)
    foox = p.apply_async(tempx, args=('2',))
    fooy = p.apply_async(tempy, args=('100', '100000'))
    print foox.get()
    print fooy.get()

if __name__ == '__main__':
    mp_handler()

apply_async无阻塞;它会立即返回一个AsyncResult对象，您可以稍后通过调用AsyncResult.get来实际获取异步操作的结果。因此，我们只需在两个函数上调用apply_async即可在后台启动它们，然后在每个get()上调用AsyncResult以等待它们完成。

另外需要注意的一点是：在您的示例中，您在子进程中所做的工作非常轻松 - 任何一项功能都不会花费很长时间。同时，产生后台进程并通过IPC将函数及其参数传递给这些后台进程，然后将结果发回的成本很高。您可能会发现使用multiprocessing比在父进程中按顺序执行这些函数要慢。为了使multiprocessing值得使用，您需要在tempx和tempy内进行更昂贵的计算。

Answer 2

不，p.map会很好地分配你的计算：它会根据你传递给它的参数并行传递给它的函数的评估。但是，在您的代码中，p.map和tempx的{{1}}应用程序不是并行的，如果这是您想要的。

但是，与普通tempy或列表推导（map）不同，[function(x) for x in your list]是异步的，不会按特定顺序返回结果。之后您需要在某些键上对结果进行排序。

使用map进行Python多处理

2 个答案: