Question

是否可以创建一个非守护进程的python池？我希望一个池能够调用一个内部有另一个池的函数。

我想要这个，因为deamon进程无法创建进程。具体来说，它会导致错误：

AssertionError: daemonic processes are not allowed to have children

例如，考虑function_a具有运行function_b的池的方案，该池具有运行function_c的池。此函数链将失败，因为function_b正在守护进程中运行，并且守护程序进程无法创建进程。

Answer 1

multiprocessing.pool.Pool类在其__init__方法中创建工作进程，使其成为守护进程并启动它们，并且无法将其daemon属性重新设置为{{1在它们开始之前（之后它不再被允许）。但是您可以创建自己的False子类（multiprocesing.pool.Pool只是一个包装函数）并替换您自己的multiprocessing.Pool子类，它始终是非守护进程的，可以使用对于工人流程。

以下是如何执行此操作的完整示例。重要的部分是顶部的两个类multiprocessing.Process和NoDaemonProcess，最后在MyPool个实例上调用pool.close()和pool.join()。

MyPool

Answer 2

multiprocessing模块有一个很好的界面，可以使用具有进程或线程的池。根据您当前的使用情况，您可以考虑将multiprocessing.pool.ThreadPool用于外部池，这将导致线程（允许从内部生成进程）而不是进程。

它可能受到GIL的限制，但在我的特定情况下（我测试了两个），来自外部Pool创建的进程的启动时间here远远超过ThreadPool的解决方案。

将Processes换成Threads真的很容易。详细了解如何使用ThreadPool解决方案here或here。

Answer 3

我有必要在Python 3.7中使用非守护程序池，并最终调整了接受的答案中发布的代码。下面是创建非守护程序池的代码段：

class NoDaemonProcess(multiprocessing.Process):
    @property
    def daemon(self):
        return False

    @daemon.setter
    def daemon(self, value):
        pass


class NoDaemonContext(type(multiprocessing.get_context())):
    Process = NoDaemonProcess

# We sub-class multiprocessing.pool.Pool instead of multiprocessing.Pool
# because the latter is only a wrapper function, not a proper class.
class MyPool(multiprocessing.pool.Pool):
    def __init__(self, *args, **kwargs):
        kwargs['context'] = NoDaemonContext()
        super(MyPool, self).__init__(*args, **kwargs)

由于multiprocessing的当前实现已被广泛地重构为基于上下文，因此我们需要提供一个以NoDaemonContext为属性的NoDaemonProcess类。 MyPool将使用该上下文，而不是默认上下文。

也就是说，我应该警告这种方法至少有两个警告：

这仍然取决于multiprocessing包的实现细节，因此可能随时中断。
multiprocessing使得使用非守护进程变得如此困难有充分的理由，here中有许多解释。我认为最引人注目的是：

关于允许子线程使用自己的方法产生自己的子代子流程冒着创建少量僵尸大军的风险 'grandchildren'，如果父线程或子线程终止子流程完成并返回。

Answer 4

concurrent.futures.ProcessPoolExecutor没有此限制。它可以有一个嵌套的过程池，完全没有问题：

from concurrent.futures import ProcessPoolExecutor as Pool
from itertools import repeat
from multiprocessing import current_process
import time

def pid():
    return current_process().pid

def _square(i):  # Runs in inner_pool
    square = i ** 2
    time.sleep(i / 10)
    print(f'{pid()=} {i=} {square=}')
    return square

def _sum_squares(i, j):  # Runs in outer_pool
    with Pool(max_workers=2) as inner_pool:
        squares = inner_pool.map(_square, (i, j))
    sum_squares = sum(squares)
    time.sleep(sum_squares ** .5)
    print(f'{pid()=}, {i=}, {j=} {sum_squares=}')
    return sum_squares

def main():
    with Pool(max_workers=3) as outer_pool:
        for sum_squares in outer_pool.map(_sum_squares, range(5), repeat(3)):
            print(f'{pid()=} {sum_squares=}')

if __name__ == "__main__":
    main()

上面的演示代码已通过Python 3.8进行了测试。

然而，ProcessPoolExecutor的局限性在于它没有maxtasksperchild。如果需要，请考虑使用answer by Massimiliano。

信用：answer by jfs

Answer 5

我遇到的问题是尝试在模块之间导入全局变量，导致ProcessPool（）行被多次评估。

<强> globals.py

from processing             import Manager, Lock
from pathos.multiprocessing import ProcessPool
from pathos.threading       import ThreadPool

class SingletonMeta(type):
    def __new__(cls, name, bases, dict):
        dict['__deepcopy__'] = dict['__copy__'] = lambda self, *args: self
        return super(SingletonMeta, cls).__new__(cls, name, bases, dict)

    def __init__(cls, name, bases, dict):
        super(SingletonMeta, cls).__init__(name, bases, dict)
        cls.instance = None

    def __call__(cls,*args,**kw):
        if cls.instance is None:
            cls.instance = super(SingletonMeta, cls).__call__(*args, **kw)
        return cls.instance

    def __deepcopy__(self, item):
        return item.__class__.instance

class Globals(object):
    __metaclass__ = SingletonMeta
    """     
    This class is a workaround to the bug: AssertionError: daemonic processes are not allowed to have children

    The root cause is that importing this file from different modules causes this file to be reevalutated each time, 
    thus ProcessPool() gets reexecuted inside that child thread, thus causing the daemonic processes bug    
    """
    def __init__(self):
        print "%s::__init__()" % (self.__class__.__name__)
        self.shared_manager      = Manager()
        self.shared_process_pool = ProcessPool()
        self.shared_thread_pool  = ThreadPool()
        self.shared_lock         = Lock()        # BUG: Windows: global name 'lock' is not defined | doesn't affect cygwin

然后从代码中的其他地方安全导入

from globals import Globals
Globals().shared_manager      
Globals().shared_process_pool
Globals().shared_thread_pool  
Globals().shared_lock

Answer 6

在某些Python版本上，将standart Pool替换为自定义项会引发错误：AssertionError: group argument must be None for now。

Here我找到了可以帮助您的解决方案：

class NonDaemonPool(multiprocessing.pool.Pool):
    def Process(self, *args, **kwds):
        proc = super(NonDaemonPool, self).Process(*args, **kwds)

        class NonDaemonProcess(proc.__class__):
            """Monkey-patch process to ensure it is never daemonized"""

            @property
            def daemon(self):
                return False

            @daemon.setter
            def daemon(self, val):
                pass

        proc.__class__ = NonDaemonProcess

        return proc

Answer 7

当错误似乎是假阳性时，这提供了一种解决方法。与noted by James一样，这可能发生在守护进程的意外 import 中。

例如，如果您具有以下简单代码，则WORKER_POOL可能会无意中从工作程序中导入，从而导致错误。

import multiprocessing

WORKER_POOL = multiprocessing.Pool()

一种简单但可靠的解决方法是：

import multiprocessing
import multiprocessing.pool


class MyClass:

    @property
    def worker_pool(self) -> multiprocessing.pool.Pool:
        # Ref: https://stackoverflow.com/a/63984747/
        try:
            return self._worker_pool  # type: ignore
        except AttributeError:
            # pylint: disable=protected-access
            self.__class__._worker_pool = multiprocessing.Pool()  # type: ignore
            return self.__class__._worker_pool  # type: ignore
            # pylint: enable=protected-access

在上述解决方法中，可以使用MyClass.worker_pool而不会出现错误。如果您认为可以改进此方法，请告诉我。

Python进程池非守护进程？

7 个答案: