Шаг 231.
Python: сборник рецептов. Конкурентность. Использование генераторов в качестве альтернативы потокам. Решение (окончание) и обсуждение

    На этом шаге мы закончим изучение этого вопроса.

    Вот продвинутый пример, показывающий использование генераторов для реализации конкурентного сетевого приложения:

from collections import deque
from select import select


# Этот класс представляет общее yield-событие в планировщике
class YieldEvent:
    def handle_yield(self, sched, task):
        pass

    def handle_resume(self, sched, task):
        pass


# Планировщик задач
class Scheduler:
    def __init__(self):
        self._numtasks = 0  # Общее количество задач
        self._ready = deque()  # Задачи, готовые к запуску
        self._read_waiting = {}  # Задачи, ждущие чтения
        self._write_waiting = {}  # Задачи, ждущие записи

    # Опрашивает на события ввода-вывода и перезапускает ждущие задачи
    def _iopoll(self):
        rset, wset, eset = select(self._read_waiting,
                                  self._write_waiting, [])
        for r in rset:
            evt, task = self._read_waiting.pop(r)
            evt.handle_resume(self, task)
        for w in wset:
            evt, task = self._write_waiting.pop(w)
            evt.handle_resume(self, task)

    def new(self, task):
        '''
        Добавляет новую запущенную задачу в планировщик
        '''
        self._ready.append((task, None))
        self._numtasks += 1

    def add_ready(self, task, msg=None):
        '''
        Добавляет уже запущенную задачу в очередь готовых.
        msg - это то, что посылается в задачу, когда она
        возобновляется.
        '''
        self._ready.append((task, msg))

    # Добавляет задачу во множество чтения
    def _read_wait(self, fileno, evt, task):
        self._read_waiting[fileno] = (evt, task)

    # Добавляет задачу во множество записи
    def _write_wait(self, fileno, evt, task):
        self._write_waiting[fileno] = (evt, task)

    def run(self):
        '''
        Запускает планировщик задач, пока задач не останется
        '''
        while self._numtasks:
            if not self._ready:
                self._iopoll()
            task, msg = self._ready.popleft()
            try:
                # Запустить корутину к следующему yield
                r = task.send(msg)
                if isinstance(r, YieldEvent):
                    r.handle_yield(self, task)
                else:
                    raise RuntimeError('unrecognized yield event')
            except StopIteration:
                self._numtasks -= 1


# Пример реализации сокетного ввода-вывода на основе корутин
class ReadSocket(YieldEvent):
    def __init__(self, sock, nbytes):
        self.sock = sock
        self.nbytes = nbytes

    def handle_yield(self, sched, task):
        sched._read_wait(self.sock.fileno(), self, task)

    def handle_resume(self, sched, task):
        data = self.sock.recv(self.nbytes)
        sched.add_ready(task, data)


class WriteSocket(YieldEvent):
    def __init__(self, sock, data):
        self.sock = sock
        self.data = data

    def handle_yield(self, sched, task):
        sched._write_wait(self.sock.fileno(), self, task)

    def handle_resume(self, sched, task):
        nsent = self.sock.send(self.data)
        sched.add_ready(task, nsent)


class AcceptSocket(YieldEvent):
    def __init__(self, sock):
        self.sock = sock

    def handle_yield(self, sched, task):
        sched._read_wait(self.sock.fileno(), self, task)

    def handle_resume(self, sched, task):
        r = self.sock.accept()
        sched.add_ready(task, r)


# Обертка вокруг объекта сокета для использования с yield
class Socket(object):
    def __init__(self, sock):
        self._sock = sock

    def recv(self, maxbytes):
        return ReadSocket(self._sock, maxbytes)

    def send(self, data):
        return WriteSocket(self._sock, data)

    def accept(self):
        return AcceptSocket(self._sock)

    def __getattr__(self, name):
        return getattr(self._sock, name)


if __name__ == '__main__':
    from socket import socket, AF_INET, SOCK_STREAM
    import time


    # Пример функции, использующей генераторы. Это нужно вызывать
    # с использованием line = yield from readline(sock)
    def readline(sock):
        chars = []
        while True:
            c = yield sock.recv(1)
            if not c:
                break
            chars.append(c)
            if c == b'\n':
                break
        return b''.join(chars)


    # Эхо-сервер, использующий генераторы
    class EchoServer:
        def __init__(self, addr, sched):
            self.sched = sched
            sched.new(self.server_loop(addr))

        def server_loop(self, addr):
            s = Socket(socket(AF_INET, SOCK_STREAM))
            s.bind(addr)
            s.listen(5)
            while True:
                c, a = yield s.accept()
                print('Got connection from ', a)
                self.sched.new(self.client_handler(Socket(c)))

        def client_handler(self, client):
            while True:
                line = yield from readline(client)
                if not line:
                    break
                line = b'GOT:' + line
                while line:
                    nsent = yield client.send(line)
                    line = line[nsent:]
            client.close()
            print('Client closed')


    sched = Scheduler()
    EchoServer(('', 16000), sched)
    sched.run()

Архив с этим файлом можно взять здесь.

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

Обсуждение

    При создании фреймворка на базе генераторов, обеспечивающих конкурентность, наиболее часто работают с более общей формой yield:

def some_generator():
    . . .
    result = yield data
    . . .

    Функции, которые используют yield этим способом, часто называются "корутинами". Внутри планировщика инструкция yield обрабатывается в цикле:

f = some_generator()

# Первоначальный результат. Это None на старте,
# поскольку ничего еще не вычислено
result = None
while True:
    try:
        data = f.send(result)
        result = ... do some calculation ...
    except StopIteration:
        break

    Логика, касающаяся result, достаточно извилиста. Передаваемое в send() значение определяет, что будет возвращено, когда инструкция yield проснется. Итак, если yield вернет результат в ответ на данные, которые были ранее выданы (yielded), он будет возвращен в следующей операции send(). Если функция-генератор только что стартовала, посылка значения None просто заставляет продвинуться к первой инструкции yield.

    В дополнение к отсылке значений также можно выполнить метод close() генератора. Это приведет к возбуждению тихого исключения GeneratorExit при достижении инструкции yield, что остановит выполнение. Если вы пожелаете, генератор может поймать это исключение и выполнить действия по очистке. Также можно использовать метод генератора throw(), чтобы возбудить произвольное исключение в инструкции yield. Планировщик задач может использовать это для передачи сообщений об ошибках в запущенных генераторах.

    Инструкция yield from, использованная в последнем примере, применяется для реализации корутин, которые служат в качестве подпрограмм или процедур, вызываемых из других генераторов. По сути, поток управления прозрачно переходит в новую функцию. В отличие от обычных генераторов, функции, которые вызываются через yield from, могут возвращать значение, которое становится результатом выполнения инструкции yield from. Дополнительные сведения об этой инструкции вы найдете в PEP 380.

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

    В качестве базового материала о корутинах и использованных в этом рецепте приемах рекомендуем PEP 342. PEP 3156 описывает современный подход к асинхронному вводу-выводу с использованием корутин. На практике вы вряд ли будете писать низкоуровневый планировщик корутин. Однако идеи, окружающие корутины, являются базой для многих популярных библиотек: gevent, greenlet, Stackless Python - и других похожих проектов.

    На следующем шаге мы рассмотрим опрашивание многопоточных очередей.




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