Шаг 227.
Python: сборник рецептов.
Конкурентность. Определение акторной задачи

    На этом шаге мы рассмотрим особенности определения такой задачи.

Задача

    Вы хотите определять задачи с поведением, аналогичным "акторам" в так называемой "модели акторов".

Решение

    "Модель акторов" - один из самых старых и простых подходов к конкурентности и распределенным вычислениям. На самом деле простота - это часть ее привлекательности. Если вкратце, то актор - это конкурентно выполняемая задача, которая просто производит действия над посылаемыми ей сообщениями. В ответ на эти сообщения актор может решить послать другие сообщения другим акторам. Коммуникация между акторами односторонняя и асинхронная. Отправляющий сообщение не знает, когда сообщение будет доставлено, а также не получает ответа или уведомления об обработке сообщения.

    Акторы определяются без особых хитростей - путем объединения потока и очереди. Например: f

rom queue import Queue
from threading import Thread, Event


# Страж, использующийся для отключения
class ActorExit(Exception):
    pass


class Actor:
    def __init__(self):
        self._mailbox = Queue()

    def send(self, msg):
        '''
        Посылает сообщение в актор
        '''
        self._mailbox.put(msg)

    def recv(self):
        '''
        Получает входящее сообщение
        '''
        msg = self._mailbox.get()
        if msg is ActorExit:
            raise ActorExit()
        return msg

    def close(self):
        '''
        Закрывает актор и отключает его
        '''
        self.send(ActorExit)

    def start(self):
        '''
        Запускает конкурентное выполнение
        '''
        self._terminated = Event()
        t = Thread(target=self._bootstrap)
        t.daemon = True
        t.start()

    def _bootstrap(self):
        try:
            self.run()
        except ActorExit:
            pass
        finally:
            self._terminated.set()

    def join(self):
        self._terminated.wait()

    def run(self):
        '''
        Запускает метод, который реализует пользователь
        '''
        while True:
            msg = self.recv()


# Пример ActorTask
class PrintActor(Actor):
    def run(self):
        while True:
            msg = self.recv()
            print("Got:", msg)


if __name__ == '__main__':
    # Пример использования
    p = PrintActor()
    p.start()
    p.send("Hello")
    p.send("World")
    p.close()
    p.join()
Архив с этим файлом можно взять здесь.

    В этом примере экземпляры Actor - это сущности, которые просто посылают сообщение, используя свой метод send(). "Под капотом" тут происходит помещение сообщения в очередь и передача его внутреннему потоку, который запущен для обработки полученных сообщений. Метод close() запрограммирован, чтобы отключать актор путем помещения специального значения-стража (ActorExit) в очередь. Пользователи определяют новые акторы путем наследования от Actor и переопределения метода run() для реализации кастомной обработки. Особенность исключения ActorExit в том, что определенный пользователем код может быть запрограммирован так, чтобы поймать запрос на завершение и правильно его обработать (исключение возбуждается методом get() и распространяется).

    Если вы ослабите требования к конкурентности и асинхронной доставке сообщений, актороподобные объекты могут быть минималистично определены с помощью генераторов. Например:

def print_actor():
    while True:
        try:
            msg = yield # Получаем сообщение
            print('Got:', msg)
        except GeneratorExit:
            print('Actor terminating')

# Пример использования
p = print_actor()
next(p) # Продвигаемся к yield (готовы к получению)
p.send("Hello")
p.send("World")
p.close()


Обсуждение

    Важная часть привлекательности акторов - их простота. На практике у нас есть только одна основная операция - send(). А общая концепция "сообщения" в основанных на акторах системах может быть расширена по многим различным направлениям. Например, вы могли бы передавать помеченные тегами сообщения в форме кортежей и заставлять акторы принимать различные решения:

class TaggedActor(Actor):
    def run(self):
        while True: 
            tag, *payload = self.recv()
            getattr(self, 'do_' + tag)(*payload)

    # Методы, соответствующие различным тегам сообщений
    def do_A(self, x):
        print('Running A', x)

    def do_B(self, x, y):
        print('Running B', x, y)

# Пример
a = TaggedActor()
a.start()
a.send(('A', 1)) # Вызывает do_A(1)
a.send(('B', 2, 3)) # Вызывает do_B(2,3)

    А вот другой пример - актор, который позволяет произвольной функции выполняться в воркере, а результатам - отправляться обратно с использованием специального объекта Result:

from actor import Actor
from threading import Event

class Result:
    def __init__(self):
        self._evt = Event()
        self._result = None

    def set_result(self, value):
        self._result = value
        self._evt.set()

    def result(self):
        self._evt.wait()
        return self._result

class Worker(Actor):
    def submit(self, func, *args, **kwargs):
        r = Result()
        self.send((func, args, kwargs, r))
        return r

    def run(self):
        while True:
            func, args, kwargs, r = self.recv()
            r.set_result(func(*args, **kwargs))

# Пример использования
if __name__ == '__main__':
    worker = Worker()
    worker.start()
    r = worker.submit(pow, 2, 3)
    print(r.result())
    worker.close()
    worker.join()

    И последнее: концепция "отправки" задачи в сообщении может быть масштабирована в системы, которые используют несколько процессов, или даже в крупные распределенные системы. Например, метод send() актороподобных объектов может быть запрограммирован для передачи данных по соединению через сокет или доставки данных через какую-то инфраструктуру передачи сообщений (например, AMOP, ZMO и т. д.).

    На следующем шаге мы рассмотрим реализация системы сообщений "опубликовать/подписаться" (pub/sub).




Предыдущий шаг Содержание Следующий шаг