ProcessPoolExecutor 的资源有限（例如 tcp 端口）

Question

动机：

我想为大量值运行一些 function（以下示例中的myfunc ），而这个 function 需要一个空闲的 TCP 端口，并且因为 TCP 端口的数量有限，我只想拥有与工作进程数。

实际上，它运行一个复杂的集成测试，为每个输入值运行许多秒或几分钟，它创建多个使用此端口进行通信的进程 - 这就是为什么需要端口的原因。 出于这个问题的目的，它是一种需要绑定到特定工作人员的有限资源。 我已将其简化为以下代码，它实际上不需要任何 TCP 端口，但我的真实代码需要，这是我问题的核心。

例子：

如果我有无限的 TCP 端口，它可能看起来像这样：

import concurrent.futures
from typing import List, Tuple

PORT_BASE = 8000

def myfunc(param: Tuple[int, int]) -> str:
    port_offset, data = param
    port = PORT_BASE + port_offset
    return 'executing %d on port %d' % (data, port)

def main() -> None:
    n = 2
    values = range(20)
    with concurrent.futures.ProcessPoolExecutor(n) as exe:
        print('\n'.join(exe.map(myfunc, enumerate(values))))

if __name__ == '__main__':
    main()

但是由于我确实对 TCP 个端口有限制，我想将一个端口“绑定”到一个工作人员 - 但我不知道如何使用ProcessPoolExecutor来做到这一点。

我想（在上面的例子的上下文中）只有 2 个 TCP 端口，这些端口将永久绑定到 2 个工人。

我使用ProcessPoolExecutor的主要原因是避免创建multiprocessing.Process es、使用multiprocessing.Queue s 传递数据、加入进程、确保所有Queue s 返回数据等。

事实上，我确实拥有它，但它并不可靠，而且它有很多代码（即 - 很多错误），所以我真的非常想切换到ProcessPoolExecutor ，根据我的经验，它“只需”使用最少的代码和几乎免维护。

唯一阻止我在这里使用ProcessPoolExecutor的是需要有限的资源 - TCP 端口。

我试过什么：

1. 使用一些“借出”端口然后“收回”以便再次“借出”的“TCP 端口管理器”，但这涉及大量共享对象以及通信和同步，最终它与原始的“进程+队列”解决方案，可能不是很可靠

2. 从 python 3.7 开始， ProcessPoolExecutor有initializer参数，我认为可以用来设置一些“worker-specific”数据，但据我了解，它只能修改全局变量，这对这种情况没有用

问题：

有没有其他方法可以设置一些“特定于工人的”数据并使用ProcessPoolExecutor将它们传递给myfunc ？

还是我唯一的希望是回到手动创建Process es 并将它们与Queue s 粘合在一起？

Answer 1

你就快到了，为了确保每个“任务”都将在一个单独的工作人员上运行，你应该使用一个multiprocessing.Barrier ，其槽位等于工作人员的数量，这将阻止工作人员从任务队列中获取多个项目，直到每个工人恰好抓住了一件物品（一种资源）

a barrier只能通过inheritance，所以应该在initializer中传递，并且每个进程绑定的端口需要保存为全局变量，以便在其他函数中使用。

import concurrent.futures
import os
from typing import List, Tuple
import multiprocessing
import multiprocessing.synchronize

PORT_BASE = 8000

def myfunc(param: Tuple[int, int]) -> str:
    global port
    # if this next line fails it will throw,
    # and you should handle it by terminating and restarting the pool
    sync_barrier.wait(timeout=5)      
    port_offset, data = param
    port = PORT_BASE + port_offset
    return 'executing %d on port %d in process %d' % (data, port, os.getpid())

def do_work(i):
    print(f"doing work {i} on port {port} in process {os.getpid()}")
def initializer_fn(barrier: multiprocessing.synchronize.Barrier):
    global sync_barrier
    sync_barrier = barrier
def main() -> None:
    n = 2
    values = range(n)
    barrier = multiprocessing.Barrier(n)
    with concurrent.futures.ProcessPoolExecutor(n,
                                                initializer=initializer_fn,
                                                initargs=(barrier,)) as exe:
        print('\n'.join(exe.map(myfunc, enumerate(values),chunksize=1)))
        exe.map(do_work,range(5))
if __name__ == '__main__':
    main()

executing 0 on port 8000 in process 15024
executing 1 on port 8001 in process 14796
doing work 0 on port 8001 in process 14796
doing work 1 on port 8000 in process 15024
doing work 2 on port 8001 in process 14796
doing work 3 on port 8000 in process 15024
doing work 4 on port 8001 in process 14796

老实说，多处理中没有任何东西“有效”，python 使它看起来很简单，但它从来没有那么简单，而且很容易搬起石头砸自己的脚。

Answer 2

我想我找到了比 Ahmed AEK 建议的解决方案更好的解决方案 - 它基于Process.name - 我可以获得当前进程名称，然后解析数字并将其用作端口偏移量。

进程名称通常是Process-1, Process-2, ...但我发现ProcessPoolExecutor创建了ForkedProcess-1名称，所以我只使用破折号后的任何名称：

更新 - 当其他进程在别处运行时，此解决方案会出现问题 - 进程名称不会从1开始 - 请参阅 Ahmed AEK 的评论 - 下面是使用自定义上下文的更好解决方案

import concurrent.futures
from multiprocessing import current_process
from typing import List, Tuple

PORT_BASE = 8000

def myfunc(data: int) -> str:
    proc_name = current_process().name
    proc_n_str = proc_name[proc_name.find('-') + 1:]
    proc_n = int(proc_n_str)
    port = PORT_BASE + proc_n
    return '%s: executing %d on port %d' % (proc_name, data, port)

def main() -> None:
    n = 2
    values = range(20)
    with concurrent.futures.ProcessPoolExecutor(n) as exe:
        print('\n'.join(exe.map(myfunc, values)))

if __name__ == '__main__':
    main()

Output：

ForkProcess-1: executing 0 on port 8001
ForkProcess-2: executing 1 on port 8002
ForkProcess-1: executing 2 on port 8001
ForkProcess-2: executing 3 on port 8002
ForkProcess-1: executing 4 on port 8001
ForkProcess-2: executing 5 on port 8002
ForkProcess-1: executing 6 on port 8001
ForkProcess-2: executing 7 on port 8002
ForkProcess-1: executing 8 on port 8001
ForkProcess-2: executing 9 on port 8002
ForkProcess-1: executing 10 on port 8001
ForkProcess-2: executing 11 on port 8002
ForkProcess-1: executing 12 on port 8001
ForkProcess-2: executing 13 on port 8002
ForkProcess-2: executing 14 on port 8002
ForkProcess-1: executing 15 on port 8001
ForkProcess-2: executing 16 on port 8002
ForkProcess-1: executing 17 on port 8001
ForkProcess-2: executing 18 on port 8002
ForkProcess-1: executing 19 on port 8001

它并不完美，因为我觉得依赖进程名称有点可疑，但它工作得很好，如果它停止了，我会这样做：

1. 准备多处理上下文（基于multiprocessing.get_context() ），它使用预设port参数创建自定义进程
2. 将上下文传递给ProcessPoolExecutor
3. 在 worker 中读取current_process().port

根据评论更新解决方案：

正如 Ahmed AEK 指出的那样，如果在其他任何地方创建了任何其他进程，我不能依赖进程名称以一个开头，所以这里是具有自定义上下文的解决方案，它应该保证正确的端口（我将它限制为 ForkContext，因为除了 linux 兼容性之外我不需要任何东西，但我认为更新使用 SpawnContext 应该不难）：

import concurrent.futures
import multiprocessing as mp

PORT_BASE = 8000

def myfunc(data: int) -> str:
    proc = mp.current_process()
    return '%s: executing %d on port %d' % (proc.name, data, proc.port)

def main() -> None:
    n = 2
    values = range(20)

    # this is used to make sure process names of `exe2` won't start at 1
    with concurrent.futures.ProcessPoolExecutor(100) as exe1:
        _ = ', '.join(exe1.map(str, range(100)))

    port_to_assign = PORT_BASE

    class ProcessWithPort(mp.context.ForkProcess):
        def __init__(self, *args, **kwargs) -> None:
            super().__init__(*args, **kwargs)
            nonlocal port_to_assign
            self.port = port_to_assign
            port_to_assign += 1

    class MyContext(mp.context.ForkContext):
        Process = ProcessWithPort

    ctx = MyContext()
    with concurrent.futures.ProcessPoolExecutor(n, mp_context=ctx) as exe2:
        print('\n'.join(exe2.map(myfunc, values)))

if __name__ == '__main__':
    main()

output：

ProcessWithPort-101: executing 0 on port 8000
ProcessWithPort-102: executing 1 on port 8001
ProcessWithPort-101: executing 2 on port 8000
ProcessWithPort-101: executing 3 on port 8000
ProcessWithPort-101: executing 4 on port 8000
ProcessWithPort-102: executing 5 on port 8001
ProcessWithPort-101: executing 6 on port 8000
ProcessWithPort-101: executing 7 on port 8000
ProcessWithPort-102: executing 8 on port 8001
ProcessWithPort-101: executing 9 on port 8000
ProcessWithPort-101: executing 10 on port 8000
ProcessWithPort-102: executing 11 on port 8001
ProcessWithPort-101: executing 12 on port 8000
ProcessWithPort-101: executing 13 on port 8000
ProcessWithPort-102: executing 14 on port 8001
ProcessWithPort-101: executing 15 on port 8000
ProcessWithPort-102: executing 16 on port 8001
ProcessWithPort-101: executing 17 on port 8000
ProcessWithPort-102: executing 18 on port 8001
ProcessWithPort-101: executing 19 on port 8000