Как сделать чтобы программа работала в фоновом режиме python
Добавил пользователь Алексей Ф. Обновлено: 18.09.2024
Я пытаюсь перенести оболочку script в гораздо более читаемую версию python. Исходная оболочка script запускает несколько процессов (утилит, мониторов и т.д.) В фоновом режиме с помощью "&". Как я могу добиться такого же эффекта в python? Я бы хотел, чтобы эти процессы не умирали, когда скрипты python завершались. Я уверен, что это как-то связано с концепцией демона, но я не мог найти, как это сделать легко.
Примечание. Этот ответ менее актуальен, чем когда он был опубликован в 2009 году. Теперь рекомендуется использовать модуль subprocess , показанный в других ответах в документах
(Обратите внимание, что модуль подпроцесса обеспечивает более мощные возможности для создания новых процессов и получения их результатов, использование этого модуля предпочтительнее использования этих функций.)
Если вы хотите, чтобы ваш процесс начинался в фоновом режиме, вы можете использовать system() и вызывать его так же, как ваша оболочка script, или вы можете spawn его:
(или, альтернативно, вы можете попробовать менее переносимый флаг os.P_NOWAIT ).
В то время как решение jkp работает, более новый способ работы (и способ, рекомендованный документацией) заключается в использовании модуля subprocess . Для простых команд это эквивалентно, но предлагает больше возможностей, если вы хотите сделать что-то сложное.
Пример для вашего случая:
Кроме того, пояснение: "Фон", как вы его здесь используете, является чисто концепцией оболочки; технически, вы имеете в виду, что хотите запустить процесс без блокировки, пока вы ждете его завершения. Тем не менее, я использовал здесь "background" для обозначения поведения, похожего на shell-background.
У меня есть веб-сервис, который запускает длительные задания (порядка нескольких часов). Я разрабатываю это, используя Flask, Gunicorn и nginx.
Я думаю о том, чтобы иметь маршрут, который занимает много времени, вызвать функцию, которая создает поток. Затем функция вернет guid обратно к маршруту, а маршрут вернет URL (используя guid), который пользователь может использовать для проверки прогресса. Я делаю поток демоном (thread.daemon = True), чтобы он завершался, если мой вызывающий код завершается (неожиданно).
Правильный ли это подход? Это работает, но это не значит, что это правильно.
4 ответа
Более регулярный подход к решению такой проблемы - извлечь действие из базового приложения и вызвать его снаружи, используя систему диспетчера задач, например Сельдерей .
Используя этот учебник , вы можете создать свою задачу и запустить ее из ваше веб-приложение.
Тогда вы можете запустить:
Просто помните, что вам нужно запускать работника отдельно:
Ну, хотя ваш подход не является неправильным, в основном это может привести к тому, что ваша программа исчерпает доступные потоки. Как упомянул Али , общий подход заключается в использовании очередей заданий, таких как RQ или Celery . Однако вам не нужно извлекать функции для использования этих библиотек. Для Flask я рекомендую вам использовать Flask-RQ . Начать просто:
Просто не забудьте установить Redis перед его использованием в приложении Flask.
И просто используйте @Job Decorator в своих функциях Flask:
И, наконец, вам нужно rqworker , чтобы запустить работника:
Вы можете посмотреть документы RQ для получения дополнительной информации. RQ разработан для простых длительных процессов.
Сельдерей
Celery более сложный, имеет огромный список функций и не рекомендуется, если вы новичок в очередях заданий и методах распределенной обработки.
Greenlets
У гринлетов есть переключатели. Позвольте вам переключаться между длительными процессами. Вы можете использовать гринлеты для запуска процессов. Преимущество заключается в том, что вам не нужен Redis и другие работники, вместо этого вы должны изменить дизайн своих функций, чтобы они были совместимы:
Ваш подход хорош и будет полностью работать, но зачем изобретать фоновый рабочий для веб-приложений на Python, когда существует широко распространенное решение, а именно сельдерей.
Мне нужно было бы увидеть много тестов, прежде чем я доверю любой домашний код для такой важной задачи.
Плюс сельдерей дает вам такие функции, как постоянство задач и возможность распределять рабочих по нескольким машинам.
Современное программное обеспечение проектируется так, что его функции и задачи могут выполняться параллельно. Python предоставляет программисту мощный набор инструментов для работы с потоками в библиотеке threading.
Как работает многопоточность
Многопоточность — это выполнение программы сразу в нескольких потоках, которые выполняют её функции одновременно.
Многопоточное программирование можно спутать с мультипроцессорным. На самом деле их концепции очень похожи, но если в первом случае программа работает с потоками, то в другом — с процессами. Разница между потоками и процессами проста: потоки имеют общую память, поэтому изменения в одном потоке видны в других, а процессы используют разные области памяти.
На самом деле, если рассмотреть одноядерный процессор, операции из разных потоков не выполняются параллельно. Одно ядро может выполнить только одну операцию в единицу времени, но так как операции выполняются очень быстро, создается ощущение параллельного выполнения, псевдопараллельность. По-настоящему параллельно программы могут работать только на многоядерных процессорах, где каждое ядро может выполнять операции независимо от других.
Отличным примером использования многопоточности является программа, где отрисовка графического интерфейса и обработка ввода пользователя управляются разными потоками. Если бы обе задачи были помещены в один поток, отрисовка интерфейса прерывалась бы каждый раз, когда программа получает ввод от пользователя. Использование двух потоков позволяет сделать выполнение этих функций независимым друг от друга.
Однако при выполнении многопоточной программы на одноядерном процессоре, её производительность будет ниже, чем если бы она была написана в один поток. Это происходит потому, что на реализацию и управление потоками тратится дополнительная память.
Можно ли считать threading многопоточным?
В Python используется GIL (Global Interpreter Lock), который однопоточный. Все потоки, которые создаются с помощью threading будут работать внутри потока GIL. В связи с этим они будут обрабатываться только одним ядром. Ни о какой работе одновременно на нескольких физических ядрах процессора не может быть и речи.
А так как threading будет выполняться только на одном ядре процессора, то нету преимущества по скорости, только наоборот — threading замедлит работу.
Но без него никуда не деться, если вам нужно выполнять несколько задач одновременно:
- Обрабатывать нажатие кнопки в графическом интерфейсе, например с помощью Tkinter. Если по нажатию кнопки надо производить много действий, которые требуют времени, то эти действия надо выполнять в другом потоке, чтобы графический интерфейс не подвис на это время. Соответственно кнопки надо блокировать, а как поток завершит вычисления — обратно разблокировать.
- Если наша программа работает одновременно с несколькими подключенными устройствами. Они могут быть подключены к разным COM-портам.
- Если мы загружаем файлы из сети и одновременно обрабатываем уже загруженные.
- И так далее…
Если нам нужно, чтобы наша программа работала на нескольких физических ядрах процессора одновременно, то следует обратить внимание на другой модуль — Multiprocessing.
В чём преимущества тогда модуля Threading по сравнению с Multiprocessing? Рассмотрим их:
Таким образом, если наша программа будет запускаться на одноядерном компьютере или нагрузка на процессор будет не большой, то Threading — оптимальный выбор.
Подключение библиотеки threading
Threading – это стандартный модуль, который поставляется вместе с интерпретатором. Программисту не нужно устанавливать его, достаточно просто подключить модуль с помощью команды:
Работать с потоками можно, создавая экземпляры класса Thread. Чтобы создать отдельный, поток нужно создать экземпляр класса и применить к нему метод start() . Вот пример:
Здесь мы функцию mydef запустили в отдельном потоке. В качестве аргументов функции передали числа 1 и 2.
threading.Thread()
Эта конструкция позволяет создать новый поток, создав экземпляр класса Thread. Вот как выглядят её аргументы:
Она принимает аргументы:
Рассмотрим их подробнее:
Демоны
Демонами называют процессы, которые работают в фоновом режиме. В Python для демона есть более конкретное значение: демонический поток или поток демона. В отличие от обычных потоков поток демона автоматически завершает свою работу при закрытии программы. Иными словами, программа не будет ожидать завершения демонического потока, при её закрытии эти потоки уничтожаются, в каком бы состоянии они не находились.
Демонические потоки используют для выполнения операций, выполняемых в бесконечном цикле. В других случаях обычно используют простые потоки, которые задерживают закрытие программы, пока не завершат выполнение всех операций. Использование демонических потоков позволяет операции в фоновом режиме, которые обычно не связаны с изменением и сохранением долгосрочных данных.
Например, если программа полностью перезаписывает содержимое файла, и механизм перезаписи реализован в демоническом потоке, то при неожиданном выходе из программы данные потеряются.
В демонические потоки часто помещают функции по рисованию графического интерфейса. Рисование интерфейса — бесконечный процесс, который завершается сразу после выхода из программы, если просто поместить его в обычный поток, это будет препятствовать закрытию программы.
Методы для работы с потоками
Для создания и управления потоками используются различные методы класса Thread. С их помощью можно легко манипулировать сразу несколькими потоками и определять их поведение.
start()
Он используется для запуска созданного потока. После использования threading.Thread() создаётся новый поток, однако он неактивен. Для того чтобы он начал работу, используется метод start().
Здесь пока мы не вызвали метод start , функция myfunc не будет запущена.
Этот метод блокирует выполнение потока, который его вызвал, до тех пор пока не завершится поток, метод которого был вызван. То есть если в потоке thread1 был вызван метод потока thread2: thread2.join(), то поток thread1 будет приостановлен до тех пор, пока выполнение thread2 не завершится.
С помощью этого метода можно заставить программу дождаться завершения демонического потока. Например, если вызвать метод в основном потоке, то программа не завершится, пока не выполнится демонический поток.
У метода join() есть аргумент timeout . По умолчанию он имеет значение None, но программист может передать в него число с плавающей точкой.
Если аргумент имеет значение по умолчанию, то выполнение потока приостанавливается, пока выполняется поток метода.
Если передать в качестве аргумента число, то для метода join() установится время ожидания, когда оно истечёт, поток продолжит свою работу.
Например, thr1.join(100) означает, что будет ожидаться завершение выполнения потока thr1 не более 100 секунд.
Так как метод join() всегда возвращает None, чтобы проверить, успел ли полностью выполниться поток за указанный timeout, нужно проверить, выполняется ли поток с помощью метода is_alive().
Здесь мы делаем поток демоническим, чтобы программа не дожидалась окончания выполнения функции. Подключаем модуль time, для того, чтобы сделать задержку в функции на 2.5 секунд. После старта потока, мы приостанавливаем основной поток на 0.125 секунд. Потом выполняем проверку is_alive(). Если выведет True, значит поток не закончил выполнение за 0.125 секунды.
В этом методе описываются операции, выполняемые потоком. Он используется, когда явно создается экземпляр класса. Пример:
Остановка потока
Бывают ситуации, когда требуется остановить поток, который работает в фоне. Допустим у нас поток у которого в функции run бесконечный цикл. В основной программе нам нужно его остановить. Тут самое простое — это создать некую переменную stop:
- В бесконечном цикле делать постоянно её проверку и если она True, то завершать его.
- Не использовать функции, которые могут блокировать выполнение на длительное время. Всегда использовать timeout.
Вот пример такой программы:
Здесь используем глобальную переменную stop. Когда нам нужно остановить поток, мы ей присваиваем значение True, а дальше просто ждём его завершения.
Состояние гонки
Состояние гонки или race condition – это ошибка, возникающая при неправильном проектировании многопоточной программы. Она возникает тогда, когда несколько потоков обращаются к одним и тем же данным. Например, переменная хранит число, которое пытаются одновременно изменить потоки thread1 и thread2, что приводит к непредсказуемым результатам или ошибке.
Распространена ситуация, когда один поток проверяет значение переменной на выполнение условия, чтобы совершить какое-то действие, но между проверкой условия и выполнением действия вмешивается второй поток, который изменяет значение переменной, что приводит к получению неправильных результатов, например:
deadlock
При использовании Lock возникает серьезная проблема, которая приводит к полной остановки работы программы. Если вызвать метод acquire(), а объект Lock уже заблокирован, то вызвавший acquire() поток будет ждать, пока заблокировавший объект поток не вызовет release().
Если один поток вызывает метод блокировки несколько раз подряд, то выполнение потока приостанавливается, пока он сам не вызовет release(). Однако он не может вызвать release, потому что его выполнение приостановлено, что означает бесконечную блокировку программы.
Самоблокировку можно предотвратить, если удалить лишний вызов acquire(), но это не всегда возможно. Самоблокировка может происходить из-за следующий вещей:
- Возникновение ошибок, когда Lock остаётся заблокированным.
- Неправильное проектирование программы, когда одна функция вызывается другой функцией, у которой отсутствует блокировка.
В случае возникновения ошибок достаточно воспользоваться конструкцией try-finally или оператором with.
Вот пример с with:
Конструкция try-finally позволяет удалять блокировку даже в случае возникновения ошибок, что позволяет избежать deadblock. Пример:
Конструкция try-finally гарантирует, что код в finally будет исполнен всегда, независимо от ошибок и результатов блока try.
Однако это не работает в случае самоблокировки из-за неправильного проектирования программы. Для этого был создан объект RLock.
RLock
Если Lock заблокирован, он блокирует любой поток, попытавшийся сделать то же самое, даже если этот поток и является владельцем блокировки в данный момент. Например, программист написал код:
Данный код будет работать, но его проблема заключается в том, что при вызове функции both_parts , в ней вызываются функции part1 и part2 . Между вызовами этих функций может получить доступ к данным какой-нибудь другой поток и их поменять. А что делать, если нужно избежать изменения другим потоком?
Чтобы решить проблему, нужно заблокировать lock1 и в both_parts , перепишем её:
Идея проста: внешняя both_parts блокирует поток на время выполнения функций part1 и part1 . Каждая из функций также блокирует поток для суммирования своей части объекта. Однако объект Lock не позволит этого сделать, этот код приведет к полному зависанию программы, потому что для Lock нет разницы, где в потоке был вызван acquire().
RLock блокирует поток только в том случае, если объект заблокирован другим потоком. Используя RLock, поток никогда не сможет заблокировать сам себя.
Также следует помнить, что, хотя и можно вызывать acquire() несколько раз, метод release() нужно вызвать столько же раз. При каждом вызове acquire() уровень рекурсии увеличивается на единицу, соответственно при каждом вызове release() он уменьшается на единицу.
Передача данных с помощью очередей (Queue)
Библиотеке queue содержит все необходимые инструменты для передачи данных между потоками и реализует нужные механизмы блокировки.
Класс Queue реализует очередь FIFO, который работает так: первый элемент, который пошел в очередь, первым и выйдет из неё. Эту очередь можно сравнить с вертикальной полой трубой, в которую сверху бросают элементы.
Queue имеет параметр maxsize, принимающий только целочисленные значения. Он указывает максимальное количество элементов, которое можно поместить в очередь. Когда максимум достигается, добавление в очередь элементов блокируется, пока в ней не освободится место. Если maxsize принимает значение myfunc выполнится через 4 секунды после вызова метода start().
Barrier
Этот класс позволяет реализовать простой механизм синхронизации потоков. Его можно использовать для фиксированного числа потоков, когда необходимо, чтобы каждый поток ждал выполнения какого-либо действия всеми.
Для того чтобы продолжить выполнения, все потоки должны вызвать метод wait(), если хоть один поток не сделал этого, остальные блокируются до тех пор, пока метод не будет вызван.
Так выглядят его аргументы:
Рассмотрим пример использования:
Здесь выставляю barrier на 2 вызова wait. То есть, для того, чтобы выполнился код после wait, wait должен быть вызван в 2 потоках. В данном случае функция myfunc сразу запускается в потоке, но она сразу не выведет 'отработал barrier' в консоль, а дождётся когда в основном потоке будет вызван wait тоже.
Event
Event представляет собой простой механизм реализации связи между потоками: один поток даёт сигнал о событии, другие ожидают этого сигнала.
Объект события управляет внутренним флагом, который может быть установлен в True или False с помощью методов set() и clear(). Также есть методы is_set(), которым можно проверить состояние внутреннего флага. С помощью метода wait(timeout=None) можно ждать пока не выставлен флаг в True. Так же при необходимости можно задать время ожидания.
Вот пример:
Возможность управления потоками в Python – это мощный инструмент в разработке больших программ. Для работы с ними используется модуль Threading и библиотека queue в связке с ним.
Каждый программист Python должен уметь работать с потоками, очередями и понимать, как устроена блокировка, доступ к данным и их передача между потоками.
def __init__( self , text, out):
self .text = text
f = open ( self .out, "a" )
f.write( self .text + '\n' )
print ( "Finished background file write to" ,
background = AsyncWrite(message, 'out.txt' )
print ( "The program can continue while it writes" )
print ( "in another thread" )
print ( "100 + 400 plain">, 100 + 400 )
print ( "Waited until thread was complete" )
if __name__ = = '__main__' :
Выход:
Цель:
Общая цель записи файлов в фоновом режиме состоит в том, что вы можете добавить свои данные в файл в фоновом режиме, в то же время заставляя программу выполнять другую задачу в программе. Вы можете записать полученные данные от пользователя в файл при выполнении другой задачи для того же пользователя.
Читайте также: