Шаг 232.
Python: сборник рецептов.
Конкурентность. Опрашивание многопоточных очередей

    На этом шаге мы рассмотрим реализацию указанной задачи.

Задача

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

Решение

    Обычное решение задачи опрашивания подразумевает использование малоизвестного трюка со скрытым зацикленным сетевым соединением. По сути, идея такова: для каждой очереди (или любого объекта), которую вы хотите опрашивать, вы создаете пару соединенных сокетов. Затем вы пишете в один из сокетов, чтобы просигнализировать о присутствии данных. Другой сокет потом передается в select() или похожую функцию для опрашивания на предмет прибытия данных. Вот пример кода, иллюстрирующий эту идею:

import queue
import socket
import os

class PollableQueue(queue.Queue):
    def __init__(self):
        super().__init__()
        # Создает пару соединенных сокетов
        if os.name == 'posix':
            self._putsocket, self._getsocket = socket.socketpair()
        else:
            # Для совместимости с не POSIX-системами
            server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            server.bind(('127.0.0.1', 0))
            server.listen(1)
            self._putsocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self._putsocket.connect(server.getsockname())
            self._getsocket, _ = server.accept()
            server.close()

    def fileno(self):
        return self._getsocket.fileno()

    def put(self, item):
        super().put(item)
        self._putsocket.send(b'x')

    def get(self):
        self._getsocket.recv(1)
        return super().get()

    Здесь мы определили экземпляр Queue нового типа, в котором зашита пара содиненных сокетов. Функция socketpair(), доступная на компьютерах с Unix, может легко установить такие сокеты. На Windows вам придется подделать ее, используя код, похожий на показанный (он выглядит немного странно, но после создания серверного сокета клиент немедленно подключается к нему). Обычные методы get() и put() здесь слегка переопределены, чтобы выполнять "минимальный" ввод-вывод на этих сокетах. Метод put() пишет единичный байт данных в один из сокетов - после помещения данных в очередь. Метод get() читает единичный байт из другого сокета и затем удаляет элемент из очереди.

    Метод fileno() - это то, что позволяет опрашивать очередь, используя методы типа select(). По сути, он просто показывает внутренний файловый дескриптор сокета, используемого функцией get(). Вот пример кода, который определяет консьюмера (потребителя), отслеживающего появление элементов во многих очередях сразу:

if __name__ == '__main__':
    import select
    import threading
    import time

    def consumer(queues):
        '''
        Консьюмер, который одновременно читает данные из нескольких очередей
        '''
        while True:
            can_read, _, _ = select.select(queues, [], [])
            for r in can_read:
                item = r.get()
                print('Got:', item)

    q1 = PollableQueue()
    q2 = PollableQueue()
    q3 = PollableQueue()
    t = threading.Thread(target=consumer, args=([q1, q2, q3],))
    t.daemon = True
    t.start()

    # Посылаем данные очередям
    q1.put(1)
    q2.put(10)
    q3.put('hello')
    q2.put(15)
Архив с этим файлом можно взять здесь.

    Если вы попробуете поэкспериментировать, то обнаружите, что консьюмер на самом деле получает все помещаемые в очередь элементы - независимо от того, в какую из очередей они помещаются.

Обсуждение

    Задача опрашивания нефайлоподобных объектов, таких как очереди, часто сложнее, чем кажется. Например, если вы не используете показанный прием с сокетами, ваш единственный вариант - написать код, который в цикле обходит очереди и использует таймер:

import time


def consumer(queues):
    while True:
        for q in queues:
            if not q.empty():
                item = q.get()
                print('Got:', item)
        # Ненадолго засыпаем, чтобы избежать 100%-ной загрузки CPU
        time.sleep(0.01)

    Для некоторых задач это может подойти, но прием довольно неуклюжий и привносит странные проблемы с производительностью. Например, если новые данные добавлены в очередь, они не будут обнаружены в течение 10 миллисекунд (для современных процессоров это целая вечность).

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

import select
  

def event_loop(sockets, queues):
    while True:
        # Опрашивание с тайм-аутом
        can_read, _, _ = select.select(sockets, [], [], 0.01)
        for r in can_read:
            handle_read(r)
        for q in queues:
            if not q.empty():
                item = q.get()
                print('Got:', item)

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

    На следующем шаге мы рассмотрим запуск процесса-демона на Unix.




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