Multithreading 如何使两个映射器函数并行运行？

我在上阅读了这个python文档

但我有如下要求：

from multiprocessing import Pool
import time

def f(x):
    print(x)
    time.sleep(100000000000000);
    return x*x

def f2(x):
    print('**' + str(x) + '**')
    time.sleep(100000000000000);
    return x*x*x;
if __name__ == '__main__':
    p = Pool(5)
    print(p.map(f, [1, 2, 3]))
    print(p.map(f2,[1,2,3]))

我有一个函数f阻塞的用例（在我的例子中，它侦听rabbitmq队列，因此它应该阻塞。我使用了一个长时间延迟1000000000000来暗示无限时间阻塞）。 我在这里用time.delay模拟了阻塞

但需要的是我希望f2（不同于f）启动并并行运行。目前它甚至没有进入f2，因为f本身会阻塞

尽管f和f2都处于阻塞状态，但有人能给出一些如何使f和f2并行启动的指导吗

更新：

似乎我找到了一条路，但困惑不解

from multiprocessing import Pool
import time

def f(x):
    print(x)
    time.sleep(100000000000000);
    return x*x

def f2(x):
    print('**' + str(x) + '**')
    time.sleep(100000000000000);
    return x*x*x;

if __name__ == '__main__':
    p = Pool(5)
    res = p.apply_async(f, [2])
    res = p.apply_async(f2,[4])
    res.get()

---

即使在重新分配res1之后，它如何工作并调用偶数f？

由于第一个池必须完成才能在第二个池之前打印结果，因此您的方法也无法工作。因此，

print

会阻碍第二个池的启动

我使用线程池同时启动两个包装器，并异步获得结果。我不得不做一个循环，而不是大的

睡眠

，因为python抱怨睡眠太大。但这是同样的事情。 在我的例子中，一次打印出1,2,31，2，3。如果我将等待循环设置为一个合理的值，我甚至可以得到一些正确的结果

from multiprocessing import Pool
import concurrent.futures


import time

sleep_times = 1000000

def f(x):
    print(x)
    for i in range(sleep_times):
        time.sleep(10)
    return x*x

def f2(x):
    print('**' + str(x) + '**')
    for i in range(sleep_times):
        time.sleep(10)
    return x*x*x;

def fwrap(l):
    p = Pool(len(l))
    return(p.map(f, l))

def fwrap2(l):
    p = Pool(len(l))
    return(p.map(f2, l))

if __name__ == '__main__':
    jr = dict()
    with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
        jr[executor.submit(fwrap, (1, 2, 3))] = "f"
        jr[executor.submit(fwrap2, (1, 2, 3))] = "f2"

    for future in concurrent.futures.as_completed(jr):
        ident = jr[future]
        print(ident,future.result())

输出（当睡眠循环减少到1以避免等待太长时间时）

在那里等待一段时间（被“处理时间”阻止），然后：

---

您的方法不起作用，因为第一个池必须完成才能在第二个池之前打印结果。因此，

print

会阻碍第二个池的启动

我使用线程池同时启动两个包装器，并异步获得结果。我不得不做一个循环，而不是大的

睡眠

，因为python抱怨睡眠太大。但这是同样的事情。 在我的例子中，一次打印出1,2,31，2，3。如果我将等待循环设置为一个合理的值，我甚至可以得到一些正确的结果

from multiprocessing import Pool
import concurrent.futures


import time

sleep_times = 1000000

def f(x):
    print(x)
    for i in range(sleep_times):
        time.sleep(10)
    return x*x

def f2(x):
    print('**' + str(x) + '**')
    for i in range(sleep_times):
        time.sleep(10)
    return x*x*x;

def fwrap(l):
    p = Pool(len(l))
    return(p.map(f, l))

def fwrap2(l):
    p = Pool(len(l))
    return(p.map(f2, l))

if __name__ == '__main__':
    jr = dict()
    with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
        jr[executor.submit(fwrap, (1, 2, 3))] = "f"
        jr[executor.submit(fwrap2, (1, 2, 3))] = "f2"

    for future in concurrent.futures.as_completed(jr):
        ident = jr[future]
        print(ident,future.result())

输出（当睡眠循环减少到1以避免等待太长时间时）

在那里等待一段时间（被“处理时间”阻止），然后：

---

您好，我在apply_async下的代码似乎可以工作。。我不知道怎么做。u-guide可以吗？

apply\u async

仅适用于1个值。您似乎希望使用列表作为输入来构建列表

apply\u async

不会这样做。您必须根据输入的顺序重新生成结果的顺序。不，我希望f和f2都启动，并且一个不应该阻止另一个，对吗？是的，但我认为您希望传递一个列表并检索一个列表。不，我希望两个阻止函数f和f2同时启动Hi，我在apply_async下的代码似乎可以工作。。我不知道怎么做。u-guide可以吗？

apply\u async

仅适用于1个值。您似乎希望使用列表作为输入来构建列表

apply\u async

不会这样做。您必须根据输入的顺序重新生成结果的顺序。否，我希望f和f2都启动，并且一个不应该阻止另一个，对吗？是的，但我认为您希望传递列表并检索列表。否，我希望两个阻止函数f和f2同时启动

('f', [1, 4, 9])
('f2', [1, 8, 27])