在 2/3 工作的线程中运行某些东西的正确方法？

Question

我在网上找到的每一个结果要么非常老，特定于 Python 2.7 或 3.x，要么太复杂以至于我无法理解。我的用例非常简单，但我很难找到一个简单的解决方案。我现有的代码如下所示：

return_val = func_that_makes_a_request(val1, val2)

lots = "of"
other()
code()
foo = some_other_func_that_makes_a_request(val3, val4)

something_else(foo, return_val)

第一行结束发出 HTTP 请求。接下来的几行计算一些值，然后用于在第 2 到最后一行中发出另一个 HTTP 请求。这两个部分（顶行，除最后一行之外的所有内容）彼此完全独立。最后一行需要两者的结果。

我真正想要的是并行发出这两个 HTTP 请求，因为两者都不需要等待另一个。在 Python 2.7+ 中工作的最简单方法是什么？

为未来的读者编辑 使用这个解决方案：

with multiprocessing.dummy.Pool(1) as thread_pool:
    return_async = thread_pool.apply_async(func_that_makes_a_request, (val1, val2))

    lots = "of"
    other()
    code()
    foo = some_other_func_that_makes_a_request(val3, val4)

    return_val = return_async.get()

    something_else(foo, return_val)

Answer 1

stdlib 中的低级 threading 模块在 2.6+ 和 3.x 中是相同的，至少对于您正在做的基本工作而言。这有点笨拙，因为开箱即用它没有为线程任务提供任何返回值的方法，但是您可以非常简单地添加它。例如：

class ReturningThread(threading.Thread):
    def run(self):
        try:
            if self._target:
                self._result = self._target(*self._args, **self._kwargs)
        finally:
            del self._target, self._args, self._kwargs
    # I'm breaking the optional timeout parameter to simplify
    def join(self):
        super(threading.Thread, self).join()
        return self._result

现在：

t1 = ReturningThread(target=func_that_makes_a_request, args=(val1, val2))

lots = "of"
other()
code()
t2 = ReturningThread(target=some_other_func_that_makes_a_request, args=(val3, val4))

return_val = t1.join()
something_else(foo, return_val)
other_return_val_we_dont_need_until_later = t2.join()

---

multiprocessing.dummy 模块允许您在线程之上使用更高级别的multiprocessing 样式Pool 和类似的构造。

with multiprocessing.dummy.Pool(2) as p:
    return_async = p.apply_async(func_that_makes_a_request, val1, val2)

    lots = "of"
    other()
    code()
    return_async_2 = p.apply_async(some_other_func_that_makes_a_request, val3, val4)

    return_val = return_async.get()
    something_else(foo, return_val)
    other_return_val_we_dont_need_until_later = return_async_2.get()

---

concurrent.futures 模块是做你想做的最简单的方法，但它在 2.7 中不存在，所以你需要pip install futures 来获取 2.7 的反向端口，然后在文件顶部：

try:
    from concurrent import futures
except ImportError:
    import futures

关于这个的好处是，您尝试执行的操作与文档中的示例之一相匹配。但是，由于您并没有真正使用任何池/执行器功能（例如能够并行等待多个结果或组合期货），它最终将与 multiprocessing 示例相同，但命名不同：

with futures.ThreadPoolExecutor(max_workers=2) as x:
    return_future = x.submit(func_that_makes_a_request, val1, val2)

    lots = "of"
    other()
    code()
    return_fut_2 = x.submit(some_other_func_that_makes_a_request, val3, val4)

    return_val = return_fut.result()
    something_else(foo, return_val)
    other_return_val_we_dont_need_until_later = return_fut_2.result()

Answer 2

multiprocessing 模块可以轻松地同时计算多个事物，尤其是使用 Pool.map。通常这是为了将一个函数应用于不同的值，而不是完全不同的函数，但我们可以轻松地扭转这一局面。

from multiprocessing.dummy import Pool
import time

def func1():
    print('starting 1')
    time.sleep(2)
    return 1

def func2():
    print('starting 2')
    time.sleep(2)
    return 2

def run_in_parallel(*funcs):
    return Pool(len(funcs)).map(lambda f: f(), funcs)

result1, result2 = run_in_parallel(func1, func2)

print(result1 + result2)

请注意，multiprocessing.dummy 表示我们正在使用线程。如果您想要真正独立的进程（由于您发出不受 CPU 限制的 HTTP 请求，因此您不需要这些进程），您将删除 .dummy。

编辑：

以上是一个可运行的示例，在您的情况下是：

def func1():
    return func_that_makes_a_request(val1, val2)

def func2():
    lots = "of"
    other()
    code()
    return some_other_func_that_makes_a_request(val3, val4)

return_val, foo = run_in_parallel(func1, func2)