Как заставить Python ждать

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

В этих и многих других ситуациях вам нужно будет найти способ заставить ваш скрипт ждать, и это не так просто, как кажется, если вы хотите сделать это правильно! В этой статье я покажу вам несколько разных способов подождать.Я собираюсь использовать Python для всех примеров, но концепции, которые я собираюсь представить, применимы ко всем языкам программирования.

Пример приложения, ожидающего

Чтобы показать вам эти шаблоны ожидания, я собираюсь использовать пример приложения, показанный ниже:

  из случайного импорта случайным образом
импорт потоковой передачи
время импорта

результат = Нет

def background_calculation ():
    # вот несколько длинных вычислений
    time.sleep (случайный () * 5 * 60)

    # когда расчет завершен, результат сохраняется в глобальной переменной
    глобальный результат
    результат = 42

def main ():
    thread = резьба.Тема (цель = background_calculation)
    thread.start ()

    # TODO: дождитесь появления результата, прежде чем продолжить!

    print ('Результат', результат)

если __name__ == '__main__':
    основной()
  

В этом приложении функция background_calculation () выполняет некоторые медленные вычисления. Чтобы упростить этот пример, я закодировал эту функцию с помощью вызова time.sleep () со случайным временем до 5 минут. Когда функция достигает конца, глобальная переменная result устанавливается с результатом этого выдуманного вычисления, которым, очевидно, будет число сорок два.

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

Уродливые: занятое ожидание

Самый простой и интуитивно понятный способ выполнить это ожидание — использовать цикл while:

  # подождите, пока будет доступен результат, прежде чем продолжить
    а результат - Нет:
        проходить
  

Если вы хотите попробовать это, вот полный сценарий, который вы можете скопировать / вставить:

  из случайного импорта случайным образом
импорт потоковой передачи
время импорта

результат = Нет

def background_calculation ():
    # вот несколько длинных вычислений
    время.сон (случайный () * 5 * 60)

    # когда расчет завершен, результат сохраняется в глобальной переменной
    глобальный результат
    результат = 42

def main ():
    thread = threading.Thread (target = background_calculation)
    thread.start ()

    # подождите здесь, пока будет доступен результат, прежде чем продолжить
    а результат - Нет:
        проходить

    print ('Результат', результат)

если __name__ == '__main__':
    основной()
  

Это действительно плохой способ ждать. Вы можете сказать почему?

Если вы хотите испытать это, вы можете попробовать сценарий в своей системе.Как только сценарий запустится, откройте диспетчер задач в Windows, Activity Monitor на Mac или, возможно, top , если вы предпочитаете командную строку. Посмотрите на использование ЦП и обратите внимание, как оно зашкаливает.

Этот цикл while кажется пустым, и на самом деле так оно и есть, за единственным исключением, что условие выхода из цикла нужно проверять снова и снова, чтобы определить, когда цикл должен выйти. Таким образом, хотя тело цикла полностью пусто, Python вынужден непрерывно оценивать , результат - None , и на самом деле тот факт, что цикл пуст, заставляет Python полностью сосредоточиться на повторении этой оценки как можно быстрее, сжигая много ЦП переходит в цикл, и все остальное на нем работает намного медленнее!

Этот тип цикла ожидания часто называется ожиданием занятости .И процессор, который застрял и не выполняет много работы, как в этом случае, как говорят, вращается вокруг . Никогда не делай этого.

Плохое: занятое ожидание со сном

Интересно, что в примере с занятым ожиданием из предыдущего раздела вы могли подумать, что наличие пустого цикла должно давать меньше работы ЦП, но на самом деле происходит обратное. Таким образом, очевидным улучшением предыдущего решения является добавление чего-то внутри цикла while, которое тормозит процессор, лихорадочно оценивая условие выхода из цикла while.

Я уверен, что многие из вас догадаются, что мы можем сделать внутри цикла, чтобы немного замедлить работу. Мы можем спать:

  # подождите, пока будет доступен результат, прежде чем продолжить
    а результат - Нет:
        время сна (15)
  

Вот весь скрипт, если вы хотите запустить его локально:

  из случайного импорта случайным образом
импорт потоковой передачи
время импорта

результат = Нет

def background_calculation ():
    # вот несколько длинных вычислений
    время.сон (случайный () * 5 * 60)

    # когда расчет завершен, результат сохраняется в глобальной переменной
    глобальный результат
    результат = 42

def main ():
    thread = threading.Thread (target = background_calculation)
    thread.start ()

    # подождите здесь, пока будет доступен результат, прежде чем продолжить
    а результат - Нет:
        время сна (15)

    print ('Результат', результат)

если __name__ == '__main__':
    основной()
  

Функция time.sleep () приостанавливает выполнение на количество секунд, указанное в аргументе.В приведенном выше примере мы спим в течение 15 секунд на каждой итерации цикла, что означает, что Python будет оценивать условие выхода из цикла только со скоростью четыре раза в минуту, по сравнению с такой скоростью, как это было в предыдущей версии. В течение этих 15 секунд сна ЦП не будет выполнять никакой работы и сможет свободно выполнять работу других процессов, запущенных на вашем компьютере.

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

Хотя это решение намного лучше предыдущего, у него есть две проблемы, которые по-прежнему делают его не идеальным. Прежде всего, этот цикл по-прежнему квалифицируется как ожидание занятости. Он использует намного меньше ЦП, чем предыдущий, но у нас все еще есть вращающийся ЦП. Мы просто сделали это терпимым, снизив частоту вращения.

Вторая проблема, на мой взгляд, больше беспокоит. Представьте, что фоновой задаче, выполняющей этот расчет, требуется ровно 61 секунда для завершения своей работы и получения результата.Если наш цикл ожидания начинается примерно в то же время, когда начинается задача, он будет проверять значение переменной result на 0, 15, 30, 45, 60 и 75 секундах. Проверка на 60 секундах все равно вернет False , потому что у фоновой задачи еще есть еще одна секунда, поэтому проверка на 75 секундах вызовет выход из цикла. Вы видите проблему? Цикл завершился на 75 секундах, но фоновая задача завершилась на 61, поэтому ожидание продлилось еще на 14 секунд!

Хотя этот тип ожидания очень распространен, у него есть проблема «разрешения», когда продолжительность ожидания кратна количеству сна, которое вы выполняете внутри цикла.Если вы спите меньше, время ожидания будет более точным, но загрузка ЦП возрастет из-за ожидания. Если вы спите больше, вы потребляете меньше ресурсов процессора, но в итоге вы можете ждать намного дольше, чем нужно.

Хорошее # 1: Присоединяйтесь к теме

Допустим, мы хотим, чтобы ожидание было максимально эффективным. Мы хотим, чтобы ожидание закончилось именно в тот момент, когда поток вычислений выдаст результат. Как мы можем сделать это?

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

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

Нарезание резьбы .Класс Thread из стандартной библиотеки Python имеет метод join () , который вернется в тот момент, когда поток завершится:

  # подождите, пока будет доступен результат, прежде чем продолжить
    thread.join ()
  

А вот и полный сценарий:

  из случайного импорта случайным образом
импорт потоковой передачи
время импорта

результат = Нет

def background_calculation ():
    # вот несколько длинных вычислений
    time.sleep (случайный () * 5 * 60)

    # когда расчет завершен, результат сохраняется в глобальной переменной
    глобальный результат
    результат = 42

def main ():
    thread = резьба.Тема (цель = background_calculation)
    thread.start ()

    # подождите здесь, пока будет доступен результат, прежде чем продолжить
    thread.join ()

    print ('Результат', результат)

если __name__ == '__main__':
    основной()
  

Вызов join () блокируется так же, как time.sleep () , но вместо блокировки на фиксированный период времени он будет блокироваться во время выполнения фонового потока. В тот момент, когда поток завершается, функция join () собирается вернуться, и приложение может продолжить работу.Операционная система значительно упрощает эффективное ожидание!

Добро №2: Ожидание события

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

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

  из случайного импорта случайным образом
импорт потоковой передачи
время импорта

результат = Нет

def background_calculation ():
    # вот несколько длинных вычислений
    time.sleep (случайный () * 5 * 60)

    # когда расчет завершен, результат сохраняется в глобальной переменной
    глобальный результат
    результат = 42

    # проделаем еще немного работы перед выходом из потока
    время.сон (10)

def main ():
    thread = threading.Thread (target = background_calculation)
    thread.start ()

    # подождите здесь, пока будет доступен результат, прежде чем продолжить
    thread.join ()

    print ('Результат', результат)

если __name__ == '__main__':
    основной()
  

Если вы запустите приведенную выше версию примера, результат будет сообщен с опозданием на 10 секунд, потому что поток остается запущенным в течение этого времени после генерации результата. Но, конечно, мы хотим сообщить результат в тот момент, когда он станет доступен.

Для подобных ситуаций, когда вам нужно дождаться произвольного состояния, мы можем использовать объект Event , который входит в пакет threading из стандартной библиотеки Python. Вот как создать событие:

  result_available = threading.Event ()
  

События имеют метод wait () , который мы будем использовать для записи нашего ожидания:

  # подождите, пока будет доступен результат, прежде чем продолжить
    result_available.Подождите()
  

Разница между методами Event.wait () и Thread.join () заключается в том, что последний предварительно запрограммирован на ожидание определенного события, которое является концом потока. Первый — это событие общего назначения, которое может ждать чего угодно. Итак, если этот объект события может ждать при любом условии, как нам сказать ему, когда нужно закончить ожидание? Для этого у объекта события есть метод set () . Сразу после того, как фоновый поток устанавливает глобальную переменную result , он может установить событие, в результате чего любой ожидающий его код разблокируется:

  # когда расчет закончен, результат сохраняется в глобальной переменной
    глобальный результат
    результат = 42
    result_available.устанавливать()
  

Вот полный код этого примера:

  из случайного импорта случайным образом
импорт потоковой передачи
время импорта

результат = Нет
result_available = threading.Event ()

def background_calculation ():
    # вот несколько длинных вычислений
    time.sleep (случайный () * 5 * 60)

    # когда расчет завершен, результат сохраняется в глобальной переменной
    глобальный результат
    результат = 42
    result_available.set ()

    # проделаем еще немного работы перед выходом из потока
    время.сон (10)

def main ():
    thread = threading.Thread (target = background_calculation)
    thread.start ()

    # подождите здесь, пока будет доступен результат, прежде чем продолжить
    result_available.wait ()

    print ('Результат', результат)

если __name__ == '__main__':
    основной()
  

Итак, здесь вы можете увидеть, как фоновый поток и основной поток синхронизируются вокруг этого объекта Event .

Хорошее № 3: Ожидание с отображением процента прогресса

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

  exit_thread = Ложь

def background_thread ():
    пока не exit_thread:
        # поработай немного
        время сна (10)
  

Здесь мы пытаемся написать поток, который можно корректно завершить, установив для глобальной переменной exit_thread значение True . Это довольно распространенный паттерн, но теперь вы, вероятно, можете определить, почему это не лучшее решение, верно? С момента установки переменной exit_thread до фактического выхода из потока может пройти до 10 секунд, и это без учета дополнительного времени, которое может пройти, пока поток не достигнет оператора сна.

Мы можем написать это гораздо более эффективно, используя объект Event , воспользовавшись аргументом timeout , который может быть передан в метод Event.wait () :

  exit_thread = threading.Event ()

def background_thread ():
    в то время как True:
        # поработай немного
        если exit_thread.wait (timeout = 10):
            перерыв
  

В этой реализации мы заменили фиксированное время ожидания на интеллектуальное ожидание объекта события.Мы все еще спим в течение 10 секунд в конце каждой итерации, но если поток застревает в вызове exit_thread.wait (timeout = 10) в тот самый момент, когда метод set () события вызывается откуда-то еще , то вызов немедленно вернет True , и поток завершится. Если истечет время ожидания 10 секунд, то вызов wait () вернет False , и поток продолжит выполнение цикла, поэтому результат будет таким же, как и при вызове time.сон (10) .

Если какая-то другая часть программы вызывает exit_thread.set () в то время, когда поток выполняет некоторую работу внутри цикла, он продолжит выполнение, но как только достигнет exit_thread.wait () вызов, он немедленно вернет True и выйдет. Секрет того, чтобы иметь возможность завершить поток без длительного ожидания, состоит в том, чтобы убедиться, что объект события проверяется достаточно часто.

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

Во-первых, давайте добавим отчеты о ходе выполнения в фоновый поток. В исходной версии я спал случайное количество секунд максимум до 300, что составляет 5 минут. Чтобы сообщать о ходе выполнения задачи за это время, я собираюсь заменить одиночный спящий режим на цикл, который выполняет 100 итераций, засыпающих немного в каждой, и это даст мне возможность сообщать процент выполнения на каждой итерации.Поскольку большой сон длился до 300 секунд, теперь я собираюсь сделать 100 снов продолжительностью до 3 секунд каждое. В целом, эта задача займет такое же количество случайного времени, но разделение работы на 100 частей позволяет легко сообщить о проценте завершения.

Вот изменения в фоновом потоке, чтобы сообщать проценты выполнения в глобальной переменной progress :

  прогресс = 0

def background_calculation ():
    # вот несколько длинных вычислений
    глобальный прогресс
    для i в диапазоне (100):
        время.сон (случайный () * 3)
        прогресс = я + 1

    # ...
  

И теперь мы можем создать более интеллектуальное ожидание, которое сообщает процент выполнения каждые 5 секунд:

  # подождите, пока будет доступен результат, прежде чем продолжить
    пока не result_available.wait (timeout = 5):
        print ('\ r {}% done ...'. format (прогресс), end = '', flush = True)
    print ('\ r {}% done ...'. format (прогресс))

  

Этот новый цикл while будет ожидать событие result_available до 5 секунд в качестве условия выхода.Если в течение этого интервала ничего не происходит, то wait () вернет False и мы попадаем в цикл, где печатается текущее значение переменной progress . Обратите внимание, что я использую символ \ r и аргументы end = '', flush = True для функции print () , чтобы предотвратить переход терминала на следующую строку. Этот трюк позволяет печатать и повторно печатать одну и ту же строку терминала, поэтому каждая строка выполнения будет печататься поверх предыдущей.

Как только фоновый расчет вызовет set () для объекта события, цикл завершится, потому что wait () немедленно вернет True , и в этот момент я выдаю еще одну печать, на этот раз с конец строки по умолчанию, чтобы я напечатал окончательный процент, а терминал оставался готовым для печати результата на следующей строке.

Вот полный код, если вы хотите его запустить или изучить более подробно:

  из случайного импорта случайным образом
импорт потоковой передачи
время импорта

прогресс = 0
результат = Нет
result_available = потоки.Мероприятие()

def background_calculation ():
    # вот несколько длинных вычислений
    глобальный прогресс
    для i в диапазоне (100):
        time.sleep (случайный () * 3)
        прогресс = я + 1

    # когда расчет завершен, результат сохраняется в глобальной переменной
    глобальный результат
    результат = 42
    result_available.set ()

    # проделаем еще немного работы перед выходом из потока
    время сна (10)

def main ():
    thread = threading.Thread (target = background_calculation)
    thread.start ()

    # подождите здесь, пока будет доступен результат, прежде чем продолжить
    пока не result_available.ждать (таймаут = 5):
        print ('\ r {}% done ...'. format (прогресс), end = '', flush = True)
    print ('\ r {}% done ...'. format (прогресс))

    print ('Результат', результат)

если __name__ == '__main__':
    основной()
  

Еще больше способов подождать!

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

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

Если вам нужно дождаться завершения подпроцесса, пакет подпроцесса предоставляет некоторые функции для запуска и ожидания процессов.

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

Если вы хотите писать приложения, которые производят и / или потребляют элементы данных, вы можете использовать объект Queue. Производитель добавляет элементы в очередь, в то время как потребитель эффективно ожидает, пока элементы заберут из него.

Как видите, в большинстве случаев операционная система предоставляет эффективные механизмы ожидания, поэтому все, что вам нужно сделать, это найти, как получить к ним доступ из Python.

Ожидание в Asyncio

Если вы используете пакет asyncio , то у вас есть доступ к аналогичным типам функций ожидания. Например, есть объекты asyncio.Event и asyncio.Queue, которые смоделированы после исходных объектов в стандартной библиотеке, но основаны на стиле программирования async / await.

Заключение

Я надеюсь, что эта статья побудит вас более тщательно подумать о том, как вы ждете в своих приложениях. Я предлагаю вам поиграть со всеми приведенными мною примерами, чтобы ознакомиться с этими методами и в конечном итоге использовать их для замены неэффективного времени .sleep () вызывает ваш код!