使用map的Python多处理

我有两种不同输入参数的方法。第一种方法只有：

u时间

，第二种方法有

u时间和foobar

我需要一个特定顺序的结果，因此我使用了map函数。但是，据我所知，上面的代码根本没有使用多进程模块，因为我使用了两个

map

函数。我说得对吗

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

我错过了什么

达诺，这是我正在做的一件事

#!/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()

---

这就是它现在的实现方式，错误被重现了

不，

p.map

将很好地分配您的计算：它将您传递给它的函数的计算与您传递给它的参数并行。但是在您的代码中，

p.map

应用程序到

tempx

和

tempy

是不并行的，如果这是您想要的

---

但是，与普通的

映射

或列表理解（

[列表中x的函数（x）]

）不同，

p.map

是异步的，不会按特定顺序返回结果。之后，您需要在某个键上对结果进行排序

不，

p.map

可以很好地分配计算：它将传递给它的函数的计算与传递给它的参数并行。但是在您的代码中，

p.map

应用程序到

tempx

和

tempy

是不并行的，如果这是您想要的

---

但是，与普通的

映射

或列表理解（

[列表中x的函数（x）]

）不同，

p.map

是异步的，不会按特定顺序返回结果。之后，您需要在某个键上对结果进行排序

不，

p.map

可以很好地分配计算：它将传递给它的函数的计算与传递给它的参数并行。但是在您的代码中，

p.map

应用程序到

tempx

和

tempy

是不并行的，如果这是您想要的

---

但是，与普通的

映射

或列表理解（

[列表中x的函数（x）]

）不同，

p.map

是异步的，不会按特定顺序返回结果。之后，您需要在某个键上对结果进行排序

不，

p.map

可以很好地分配计算：它将传递给它的函数的计算与传递给它的参数并行。但是在您的代码中，

p.map

应用程序到

tempx

和

tempy

是不并行的，如果这是您想要的

---

但是，与普通的

映射

或列表理解（

[列表中x的函数（x）]

）不同，

p.map

是异步的，不会按特定顺序返回结果。之后，您需要在某个键上对结果进行排序

Pool.map

如果您需要在一个iterable的所有元素上并行运行一个特定的函数，并阻塞直到整个iterable被处理完毕，那么它非常有用。在您的例子中，您只是在iterable中传递一个项，所以您只是在子流程中运行一个函数，并阻塞直到它完成。这比只在父进程中运行函数要慢，因为这样会增加IPC的开销

---

如果您的目标是只使用一组参数并行运行

tempx

和

tempy

，那么更好的选择是：

    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()

apply\u async

是非阻塞的；它立即返回一个对象，您可以稍后通过调用

AsyncResult.get

，使用该对象实际获取异步操作的结果。因此，我们只需在两个函数上调用

apply_async

，在后台启动它们，然后在每个

AsyncResult

上调用

get（）

，等待它们完成

---

这里还要注意的另一件事是：在您的示例中，您在子进程中所做的工作非常简单—两个函数都不需要很长时间就可以完成。相比之下，生成后台进程并通过IPC将函数及其参数传递给这些后台进程，然后将结果发送回这些进程的成本很高。您可能会发现，使用

多处理

比在父进程中顺序执行这些函数要慢。为了使

多处理

值得使用，您需要在

tempx

和

tempy

池中进行更为昂贵的计算。如果您需要在一个iterable的所有元素上并行运行特定函数，并阻塞直到整个iterable被处理完毕，map非常有用。在您的例子中，您只是在iterable中传递一个项，所以您只是在子流程中运行一个函数，并阻塞直到它完成。这比只在父进程中运行函数要慢，因为这样会增加IPC的开销

---

如果您的目标是只使用一组参数并行运行

tempx

和

tempy

，那么更好的选择是：

    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()

apply\u async

是非阻塞的；它立即返回一个对象，您可以稍后通过调用

AsyncResult.get

，使用该对象实际获取异步操作的结果。因此，我们只需在两个函数上调用

apply_async

，在后台启动它们，然后在每个

AsyncResult

上调用

get（）

，等待它们完成

这里还要注意的另一件事是：在您的示例中，您在子进程中所做的工作非常简单—两个函数都不需要很长时间就可以完成。相比之下，生成后台进程并通过IPC将函数及其参数传递给这些后台进程，然后将结果发送回这些进程的成本很高。你会成为职业选手的