Как запустить скрипт python в фоновом режиме windows

On Windows, you can use pythonw.exe in order to run a python script as a background process:

Python scripts (files with the extension .py) will be executed by
python.exe by default. This executable opens a terminal, which stays
open even if the program uses a GUI. If you do not want this to
happen, use the extension .pyw which will cause the script to be
executed by pythonw.exe by default (both executables are located in
the top-level of your Python installation directory). This suppresses
the terminal window on startup.

For example,

C:ThanosDoddPython3.6pythonw.exe C:\PythonScriptsmoveDLs.py

In order to make your script run continuously, you can use sched for event scheduling:

The sched module defines a class which implements a general purpose
event scheduler

import sched
import time

event_schedule = sched.scheduler(time.time, time.sleep)

def do_something():
    print("Hello, World!")
    event_schedule.enter(30, 1, do_something, (sc,))

event_schedule.enter(30, 1, do_something, (s,))
event_schedule.run()

Now in order to kill a background process on Windows, you simply need to run:

taskkill /pid processId /f

Where processId is the ID of the process you want to kill.

3

3

Сценарий мониторинга test1.py, написанный на python, работает в режиме True. Когда ssh удален (с помощью терминала замазки), запустите сценарий с помощью следующей команды:

python test1.py &

Теперь сценарий работает нормально, вы можете увидеть номер процесса через ps, в это время непосредственно закройте терминал ssh (не используя команду выхода, но непосредственно через кнопку закрытия putty), после входа в систему снова и найденный Процесс уже завершен.

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

бегать в фоновом режиме под окнами

Под окнами нет глубоких исследований. Метод, который я часто использую, заключается в изменении расширения скрипта Python «.pyw». Двойной щелчок запускается в фоновом режиме без изменения кода.

Запустите в фоновом режиме под Linux

Через вилку
В среде Linux процесс демона в c реализован с помощью fork, и python также может быть реализован таким образом. Пример кода следующий:

#!/usr/bin/env python
import time,platform
import os
def funzioneDemo():
    # Это пример конкретной бизнес-функции
    fout = open('/tmp/demone.log', 'w')
    while True:
        fout.write(time.ctime()+'n')
        fout.flush()
        time.sleep(2)
    fout.close()
def createDaemon():
         # форк процесс        
    try:
        if os.fork() > 0: os._exit(0)
    except OSError, error:
        print 'fork #1 failed: %d (%s)' % (error.errno, error.strerror)
        os._exit(1)    
    os.chdir('/')
    os.setsid()
    os.umask(0)
    try:
        pid = os.fork()
        if pid > 0:
            print 'Daemon PID %d' % pid
            os._exit(0)
    except OSError, error:
        print 'fork #2 failed: %d (%s)' % (error.errno, error.strerror)
        os._exit(1)
         # Перенаправить стандартный IO
    sys.stdout.flush()
    sys.stderr.flush()
    si = file("/dev/null", 'r')
    so = file("/dev/null", 'a+')
    se = file("/dev/null", 'a+', 0)
    os.dup2(si.fileno(), sys.stdin.fileno())
    os.dup2(so.fileno(), sys.stdout.fileno())
    os.dup2(se.fileno(), sys.stderr.fileno())
         # Выполнить код в дочернем процессе
    funzioneDemo() # function demo
if __name__ == '__main__': 
    if platform.system() == "Linux":
        createDaemon()
    else:
        os._exit(0)

Через выскочку

Приложение может быть упаковано как системная служба через upstart, и полный пример прямо записан здесь.

1. Напишите скрипт на Python

[[email protected] t27]# cat test123.py
#!/usr/bin/env python
import os,time
while True :
    print time.time()
    time.sleep(1)

2. Напишите файл конфигурации upstat

[[email protected] t27]# cat /etc/init/mikeTest.conf
description "My test"
author "[email protected]"
start on runlevel [234]
stop on runlevel [0156]
chdir /test/t27
exec /test/t27/test123.py
respawn

• 3. Перезагрузить северную часть штата

initctl reload-configuration

• 4. Запустите сервис

[[email protected] t27]# start mikeTest
mikeTest start/running, process 6635
[[email protected] t27]# ps aux | grep test123.py
root      6635  0.0  0.0  22448  3716 ?        Ss   09:55   0:00 python /test/t27/test123.py
root      6677  0.0  0.0 103212   752 pts/1    S+   09:56   0:00 grep test123.py

• 5. Стоп сервис

[[email protected] t27]# stop mikeTest
mikeTest stop/waiting
[[email protected] t27]# ps aux | grep test123.py
root      6696  0.0  0.0 103212   752 pts/1    S+   09:56   0:00 grep test123.py
[[email protected] t27]#

Скрипт bash

1. код Python

[[email protected] test]# cat test123.py
#!/usr/bin/env python
import os,time
while True :
    print time.time()
    time.sleep(1)

• 2. Написать скрипт запуска

[[email protected] test]# cat start.sh
#! /bin/sh
python test123.py &

• 3. Запустите процесс

[[email protected] test]#./start.sh

Если вы используете & для запуска процесса напрямую:

python test123.py &

Непосредственное закрытие терминала ssh приведет к завершению процесса.

Через экран, tmux и т. Д.

Если вы временно запустите программу, вы можете запустить программу через screen, tmux, здесь описывается, как запускается tmux.

1. Запустите tmux

Введите tmux в терминал, чтобы начать

2. Запустите программу в tmux

Просто выполните следующую команду напрямую (ссылка на скрипт выше): python test123.py

3. Закройте терминал ssh напрямую (например, кнопку закрытия на замазке);

4. После перезапуска ssh выполните следующую команду:

tmux attach

• Теперь вы можете видеть, что программа на python все еще работает нормально.

Содержание:

• Асинхронное выполнение с помощью инкрементной итерации;
• Запуск команды в фоновом процессе;
  • Использование обратных вызовов с фоновым процессом;
  • Интерактивные обратные вызовы;
  • Обратный вызов при завершении команды.

Асинхронное выполнение с помощью инкрементной итерации.

from sh import tail

# цикл будет работать вечно (если не поставить 
# таймаут или убить процесс сигналом)
for line in tail("-f", "/var/log/some_log_file.log", _iter=True):
    print(line)

По умолчанию ключевой аргумент _iter повторяет STDOUT, но можно изменить этот параметр, передав либо 'err', либо 'out' (вместо True). Кроме того, по умолчанию, выходные данные буферизуются строками, поэтому тело цикла будет выполняться только тогда, когда процесс создает новую строку. Вы можете изменить это, изменив размер буфера вывода команды с помощью _out_bufsize.

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

Запуск команды в фоновом процессе.

По умолчанию каждая запущенная команда терминала через модуль sh блокируется до завершения. Если какая-то команда выполняется длительное время, то можно запустить ее в фоновом режиме с помощью специального ключевого аргумента _bg=True:

import sh
# блокирующий вызов
sh.sleep(3)
print("...3 секунды спустя")

# НЕ блокирующий вызов
p = sh.sleep(3, _bg=True)
print("печать сразу после запуска!")
# ждем завершения `sh.sleep` 
p.wait()
print("...и 3 секунды спустя")

Наверное заметили, чтобы возвратить результат после выхода из команды нужно вызвать метод RunningCommand.wait().

Команды, запущенные в фоновом режиме, игнорируют SIGHUP, это означает, что когда их контролирующий процесс (лидер сеанса, если есть управляющий терминал) завершается, то ядро ​​не сигнализирует о их завершении. Но поскольку команды модуля sh по умолчанию запускают свои процессы в своих собственных сеансах, то есть они сами являются лидерами сеансов, игнорирование SIGHUP обычно не оказывает никакого влияния. Таким образом, единственный случай, когда игнорирование SIGHUP будет делать что-либо, — это использование ключевого аргумента _new_session=False, и в этом случае контролирующим процессом, вероятно, будет оболочка, из которой запустили python, и выход из этой оболочки обычно отправляет SIGHUP всем дочерним процессам.

Использование обратных вызовов с фоновым процессом.

В сочетании с _bg=True, модуль sh может использовать обратные вызовы для постепенной обработки выходных данных, передавая вызываемую функцию в ключевые аргументы _out и/или _err. Этот вызываемый объект будет вызываться для каждой строки (или фрагмента) данных, которые выводит команда терминала:

from sh import tail

# обратный вызов
def process_output(line):
    print(line)

p = tail("-f", "/var/log/some_log_file.log", _out=process_output, _bg=True)
p.wait()

Чтобы указать, получает ли обратный вызов строку или фрагмент, используйте ключевой аргумент _out_bufsize. Чтобы «выйти» из обратного вызова, необходимо, что бы функция обратного вызова возвратила True. Это говорит команде больше не вызывать функцию обратного вызова.

Примечание. Возврат True не убивает процесс, он только предотвращает повторный вызов обратного вызова. Смотрите «Интерактивные обратные вызовы», чтобы узнать, как убить процесс из обратного вызова.

Интерактивные обратные вызовы.

Команды, вызываемые при помощи модуля sh могут взаимодействовать с базовым процессом в интерактивном режиме через определенную сигнатуру обратного вызова. Каждая команда, запущенная через sh, имеет внутреннюю очередь STDIN, которую можно использовать из обратных вызовов:

import sh

def interact(line, stdin):
    if line == "Какова... скорость ласточки?":
        stdin.put("Африканская или европейская ласточка?")
    elif line == "Хм? Я ... этого не знаю":
        cross_bridge()
        return True
    else:
        stdin.put("Я не знаю.... AAGGHHHHH")
        return True

p = sh.bridgekeeper(_out=interact, _bg=True)
p.wait()

Примечание. Если используете очередь, то можно сигнализировать об окончании ввода (EOF) с помощью значения очереди None.

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

import sh

def process_output(line, stdin, process):
    print(line)
    if "ERROR" in line:
        process.kill()
        return True

p = sh.tail("-f", "/var/log/some_log_file.log", _out=process_output, _bg=True)

Приведенный выше код будет выполняться, печатая строки из some_log_file.log до тех пор, пока в строке не появится слово 'ERROR', после чего процесс команды tail будет убит и сценарий завершится.

Примечание. Можно также использовать RunningCommand.terminate() для отправки SIGTERM или RunningCommand.signal() для отправки другого сигнала.

Обратный вызов при завершении команды.

Функция обратного вызова, переданная ключевому аргументу с именем _done вызывается, когда процесс завершается, либо обычно (через успешный или ошибочный код выхода), либо через сигнал.

Вот пример использования ключевого аргумента _done для создания многопроцессорного пула, где sh.your_parallel_command выполняется одновременно не более 10 раз:

import sh
from threading import Semaphore

pool = Semaphore(10)

def done(cmd, success, exit_code):
    pool.release()

def do_thing(arg):
    pool.acquire()
    return sh.your_parallel_command(arg, _bg=True, _done=done)

procs = []
for arg in range(100):
    procs.append(do_thing(arg))

[p.wait() for p in procs]

@py C:\PythonScriptsmoveDLs.py %*

3 ответа

Лучший ответ

C:ThanosDoddPython3.6pythonw.exe C:\PythonScriptsmoveDLs.py

import sched
import time

event_schedule = sched.scheduler(time.time, time.sleep)

def do_something():
    print("Hello, World!")
    event_schedule.enter(30, 1, do_something, (sc,))

event_schedule.enter(30, 1, do_something, (s,))
event_schedule.run()

taskkill /pid processId /f

import shutil, os, time

while True:
    for filename in os.listdir('folderToMoveFrom'):
        if filename.endswith((desired file extensions)):
            shutil.move( (folderToMoveFrom + filename), folderToMoveTo)
    time.sleep(6)

import time

while True:
   your_script_here
   time.sleep(300)

Оба захватывают вывод и запускаются в фоновом режиме с threading

Как упоминалось на этот ответ, если вы захватите вывод с помощью stdout= а затем попробуйте read(), то процесс блокируется.

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

Компания threading модуль позволяет нам это делать.

Во-первых, посмотрите, как выполнить только часть перенаправления вывода в этом вопросе: Python Popen: запись в стандартный вывод и файл журнала одновременно

Тогда:

main.py

#!/usr/bin/env python3

import os
import subprocess
import sys
import threading

def output_reader(proc, file):
    while True:
        byte = proc.stdout.read(1)
        if byte:
            sys.stdout.buffer.write(byte)
            sys.stdout.flush()
            file.buffer.write(byte)
        else:
            break

with subprocess.Popen(['./sleep.py', '0'], stdout=subprocess.PIPE, stderr=subprocess.PIPE) as proc1, 
     subprocess.Popen(['./sleep.py', '10'], stdout=subprocess.PIPE, stderr=subprocess.PIPE) as proc2, 
     open('log1.log', 'w') as file1, 
     open('log2.log', 'w') as file2:
    t1 = threading.Thread(target=output_reader, args=(proc1, file1))
    t2 = threading.Thread(target=output_reader, args=(proc2, file2))
    t1.start()
    t2.start()
    t1.join()
    t2.join()

сон.ру

#!/usr/bin/env python3

import sys
import time

for i in range(4):
    print(i + int(sys.argv[1]))
    sys.stdout.flush()
    time.sleep(0.5)

После запуска:

./main.py

stdout обновляется каждые 0.5 секунды для каждых двух строк, содержащих:

0
10
1
11
2
12
3
13

и каждый файл журнала содержит соответствующий журнал для данного процесса.

Вдохновленный: https://eli.thegreenplace.net/2017/interacting-with-a-long-running-child-process-in-python/

Проверено на Ubuntu 18.04, Python 3.6.7.