Менеджер многопроцессорной обработки Python и совместное использование составных шаблонов

Возможно ли, что между классами существует циклическая ссылка? Например, внешний класс имеет ссылку на составной класс, а составной класс имеет обратную ссылку на внешний класс.

Диспетчер многопроцессорности работает хорошо, но когда у вас большие и сложные структуры классов, вы, вероятно, столкнетесь с ошибкой, когда тип/ссылка не могут быть правильно сериализованы. Другая проблема заключается в том, что ошибки диспетчера многопроцессорности очень загадочны. Это еще больше усложняет отладку условий сбоя.

Я думаю, проблема в том, что вы должны проинструктировать менеджера о том, как управлять вашим объектом, который не является стандартным типом Python.

В других мирах вы должны создать для себя прокси-сервер CompositeDict

Пример можно посмотреть в этом документе: http://ruffus.googlecode.com/svn/trunk/doc/html/sharing_data_across_jobs_example.html

Python имеет максимальную глубину рекурсии по умолчанию 1000 (или 999, я забыл...). Но вы можете изменить поведение по умолчанию следующим образом:

import sys
sys.setrecursionlimit(n)

Где n — количество рекурсий, которые вы хотите разрешить.

Изменить:

Приведенный выше ответ ничего не делает для решения основной причины этой проблемы (как указано в комментариях). Его нужно использовать только в том случае, если вы намеренно повторяете более 1000 раз. Если вы находитесь в бесконечном цикле (как в этой задаче), вы в конечном итоге достигнете любого установленного вами предела.

Чтобы решить вашу настоящую проблему, я переписал ваш код с нуля, начав так просто, как только мог, и построил его так, как я считаю, что вы хотите:

import sys
from multiprocessing import Process
from multiprocessing.managers import BaseManager
from CompositDict import *

class Shared():
    def __init__(self):
        self.comp = CompositeDict('Comp')

    def get_comp(self):
        return self.comp

    def set_comp(self, c):
        self.comp = c

class Manager():
    def __init__(self):
        shared = Shared()
        BaseManager.register('get_shared', callable=lambda:shared)
        mgr = BaseManager(address=('127.0.0.1', 50000), authkey='abracadabra')
        srv = mgr.get_server()
        srv.serve_forever()

class Consumer():
    def __init__(self, child_name):
        BaseManager.register('get_shared')
        mgr = BaseManager(address=('127.0.0.1', 50000), authkey='abracadabra')
        mgr.connect()

        shared = mgr.get_shared()
        comp = shared.get_comp()
        child = comp.addChild(child_name)
        shared.set_comp(comp)
        print comp

class Controller():
    def __init__(self):
        pass

    def main(self):
        m = Process(target=Manager, name='Manager')
        m.daemon = True
        m.start()

        consumers = []
        for i in xrange(3):
            p = Process(target=Consumer, name='Consumer', args=('Consumer_' + str(i),))
            p.daemon = True
            consumers.append(p)

        for c in consumers:
            c.start()
        for c in consumers:
            c.join()
        return 0


if __name__ == '__main__':
    con = Controller()
    sys.exit(con.main())

Я сделал это все в одном файле, но у вас не должно возникнуть проблем с его разбивкой.

Я добавил аргумент child_name вашему потребителю, чтобы проверить, обновляется ли CompositDict.

Обратите внимание, что для вашего объекта CompositDict существует как геттер, так и сеттер. Когда у меня был только геттер, каждый потребитель перезаписывал CompositDict, когда добавлял дочерний элемент.

Вот почему я также изменил ваш зарегистрированный метод на get_shared вместо get_comp, так как вам понадобится доступ к установщику, а также к получателю в вашем классе Consumer.

Кроме того, я не думаю, что вы хотите попробовать присоединиться к процессу вашего менеджера, так как он будет «служить вечно». Если вы посмотрите на исходный код BaseManager (./Lib/multiprocessing/managers.py:Line 144), вы заметите, что функция serve_forever() помещает вас в бесконечный цикл, который прерывается только KeyboardInterrupt или SystemExit.

Суть в том, что этот код работает без рекурсивного зацикливания (насколько я могу судить), но дайте мне знать, если вы все еще сталкиваетесь с ошибкой.