如何使用 Python 的 concurrent.futures 跨多个进程对任务进行排队，每个进程都有自己的线程池？

Question

我正在开发一个库 function，它使用concurrent.futures跨多个线程传播网络 I/O。 由于 Python GIL，我的某些工作负载（大文件）速度变慢，因此我想切换到多个进程。 但是，对于某些其他工作负载（许多小文件），多个进程也不太理想。 我想拆分差异并拥有多个进程，每个进程都有自己的线程池。

问题是作业排队 - concurrent.futures似乎没有设置为多个进程正确排队作业，每个进程都可以一次处理多个作业。 虽然提前将作业列表分成块是一种选择，但如果作业在各个线程完成任务时异步地流向每个进程，则工作会更加顺利。

我如何使用这个或类似的 API 有效地跨多个进程和线程排队作业？ 除了编写我自己的执行程序之外，是否有任何我忽略的明显解决方案？ 或者是否有混合进程/线程执行器的现有技术？

Answer 1

如果我明白你想做什么，你基本上有很多适合多线程的工作，除了有一些 CPU 密集型工作。 所以你的想法是在多个子进程中创建多个线程池，从而减少 GIL 争用。 当然，在任何给定的子进程中，CPU 密集型代码只会串行执行（假设它是 Python 字节代码），因此这不是一个完美的解决方案。

一种方法是创建一个非常大的多处理池（大于您拥有的内核数）。 您可以创建的进程数量是有限的，而且创建它们的成本很高。 但由于大部分时间他们将等待 I/O 完成，因此 I/O 部分将并发执行。

更好的方法是创建一个多处理池，其执行程序可以传递给多线程池工作程序 function 以及其他所需的 arguments。这与您计划执行的操作相反。 当 worker function 有一个 CPU 密集型工作要执行时，它可以将该工作提交给传递的多处理池执行器并阻塞返回结果。 通过这种方式，您可以获得最佳的并行性，您可以在给定您拥有的内核数量的情况下实现。 这是我的建议。 . 例如：

from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor, as_completed

def cpu_intensive(x):
    return x ** 2

def thread_worker(process_executor, x):
    import time

    # Do something with x
    ...
    time.sleep(.1) # simulate time taken
    future = process_executor.submit(cpu_intensive, x)
    squared = future.result() # Just for demo purposes
    return x, squared

if __name__ == '__main__':
    input_args = (100, 200, 300, 400, 500)
    with ProcessPoolExecutor() as process_executor:
        with ThreadPoolExecutor(10) as thread_executor:
            # Each input results in multiple threading jobs being created:
            futures = [
                thread_executor.submit(thread_worker, process_executor, input_arg + i)
                    for input_arg in input_args
                        for i in range(5)
            ]
            results = [future.result() for future in as_completed(futures)]
    print(results)

印刷：

[(204, 41616), (202, 40804), (203, 41209), (200, 40000), (201, 40401), (104, 10816), (103, 10609), (102, 10404), (101, 10201), (100, 10000), (402, 161604), (303, 91809), (302, 91204), (301, 90601), (400, 160000), (300, 90000), (304, 92416), (403, 162409), (401, 160801), (404, 163216), (500, 250000), (501, 251001), (504, 254016), (503, 253009), (502, 252004)]

但是如果你想 go 与你最初的想法一起，或者由于某种原因上面的框架不适合你的实际情况，也许像下面这样的东西可能会起作用：

from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor, as_completed
from multiprocessing import Queue
from queue import Empty

def init_pool_processes(q):
    global queue, thread_pool_executor

    queue = q
    thread_pool_executor = ThreadPoolExecutor(10) # or some appropriate pool size


def thread_worker(x):
    import time

    # Do something with x
    ...
    time.sleep(.1) # simulate time taken
    return x # Just for demo purposes

def process_worker(y):
    # This results in some number of threadpool jobs:
    futures = [thread_pool_executor.submit(thread_worker, y + i) for i in range(5)]
    for future in as_completed(futures):
        queue.put(future.result())


if __name__ == '__main__':
    results = []

    def get_results(result):
        try:
            while True:
                result = queue.get_no_wait()
                results.append(result)
        except Empty:
            pass

    input_args = (100, 200, 300, 400, 500)
    queue = Queue()
    with ProcessPoolExecutor(initializer=init_pool_processes, initargs=(queue,)) as executor:
        futures = [executor.submit(process_worker, input_arg) for input_arg in input_args]
        for future in as_completed(futures):
            # Every time a job submitted to the process pool completes we can
            # look for more results:
            try:
                while True:
                    result = queue.get_nowait()
                    results.append(result)
            except Empty:
                pass
    print(results)

印刷：

[102, 201, 101, 203, 103, 202, 200, 100, 104, 204, 504, 301, 404, 502, 304, 403, 302, 501, 503, 500, 402, 303, 401, 300, 400]