Jak rozpocząć proces w tle w Pythonie?

Próbuję przenieść skrypt powłoki do znacznie bardziej czytelnej wersji Pythona. Oryginalny skrypt powłoki uruchamia w tle kilka procesów (programy narzędziowe, monitory itp.) Za pomocą „&”. Jak mogę osiągnąć ten sam efekt w Pythonie? Chciałbym, aby te procesy nie umarły po zakończeniu skryptów Pythona. Jestem pewien, że ma to jakoś związek z koncepcją demona, ale nie mogłem znaleźć łatwego sposobu.

Uwaga : ta odpowiedź jest mniej aktualna niż w momencie opublikowania w 2009 roku. Korzystanie z subprocessmodułu przedstawionego w innych odpowiedziach jest teraz zalecane w dokumentacji

(Należy pamiętać, że moduł podprocesu zapewnia bardziej zaawansowane funkcje do tworzenia nowych procesów i wyszukiwania ich wyników; korzystanie z tego modułu jest lepsze niż korzystanie z tych funkcji).

Jeśli chcesz, aby proces rozpoczął się w tle, możesz użyć go system()i wywołać w taki sam sposób, jak skrypt powłoki lub możesz spawn:

import os
os.spawnl(os.P_DETACH, 'some_long_running_command')

(lub alternatywnie możesz wypróbować mniej przenośną os.P_NOWAITflagę).

Zobacz dokumentację tutaj .

Podczas gdy rozwiązanie jkp działa, nowszym sposobem robienia rzeczy (i zaleceniami dokumentacji) jest użycie subprocessmodułu. W przypadku prostych poleceń jest to odpowiednik, ale oferuje więcej opcji, jeśli chcesz zrobić coś skomplikowanego.

Przykład twojej sprawy:

import subprocess
subprocess.Popen(["rm","-r","some.file"])

To będzie działać rm -r some.filew tle. Zauważ, że wywołanie .communicate()zwróconego obiektu Popenbędzie blokować, dopóki się nie zakończy, więc nie rób tego, jeśli chcesz, aby działał w tle:

import subprocess
ls_output=subprocess.Popen(["sleep", "30"])
ls_output.communicate()  # Will block for 30 seconds

Zobacz dokumentację tutaj .

Należy również wyjaśnić: „Tło”, kiedy go używasz, jest wyłącznie koncepcją powłoki; technicznie masz na myśli to, że chcesz odrodzić proces bez blokowania go podczas oczekiwania na jego zakończenie. Jednak użyłem tutaj „tła”, aby odnieść się do zachowania przypominającego tło powłoki.

Prawdopodobnie potrzebujesz odpowiedzi na „Jak wywołać zewnętrzne polecenie w Pythonie” .

Najprostszym podejściem jest użycie os.systemfunkcji, np .:

import os
os.system("some_command &")

Zasadniczo wszystko, co przekażesz do systemfunkcji, zostanie wykonane tak samo, jakbyś przekazał ją do powłoki w skrypcie.

Znalazłem to tutaj :

W systemie Windows (Win XP) proces nadrzędny nie zakończy się, dopóki longtask.pynie zakończy pracy. To nie jest to, czego chcesz w skrypcie CGI. Problem nie jest specyficzny dla Pythona, w społeczności PHP problemy są takie same.

Rozwiązaniem jest przekazanie DETACHED_PROCESS flagi tworzenia procesu do podstawowej CreateProcessfunkcji w win API. Jeśli akurat masz zainstalowany pywin32, możesz zaimportować flagę z modułu win32process, w przeciwnym razie powinieneś ją zdefiniować samodzielnie:

DETACHED_PROCESS = 0x00000008

pid = subprocess.Popen([sys.executable, "longtask.py"],
                       creationflags=DETACHED_PROCESS).pid

Używaj subprocess.Popen()z close_fds=Trueparametrem, który pozwoli odłączyć spawnowany podproces od samego procesu Pythona i kontynuować działanie nawet po wyjściu z Pythona.

https://gist.github.com/yinjimmy/d6ad0742d03d54518e9f

import os, time, sys, subprocess

if len(sys.argv) == 2:
    time.sleep(5)
    print 'track end'
    if sys.platform == 'darwin':
        subprocess.Popen(['say', 'hello'])
else:
    print 'main begin'
    subprocess.Popen(['python', os.path.realpath(__file__), '0'], close_fds=True)
    print 'main end'

Prawdopodobnie chcesz rozpocząć badanie modułu os w celu tworzenia różnych wątków (otwierając sesję interaktywną i udzielając pomocy (os)). Odpowiednimi funkcjami są fork i dowolne z nich. Aby dać ci pomysł, jak zacząć, umieść coś takiego w funkcji wykonującej rozwidlenie (funkcja musi wziąć listę lub krotkę „argumenty” jako argument zawierający nazwę programu i jego parametry; możesz również chcieć aby zdefiniować standardowe wejście, wyjście i błąd dla nowego wątku):

try:
    pid = os.fork()
except OSError, e:
    ## some debug output
    sys.exit(1)
if pid == 0:
    ## eventually use os.putenv(..) to set environment variables
    ## os.execv strips of args[0] for the arguments
    os.execv(args[0], args)

Oba wychwytują dane wyjściowe i działają w tle za pomocą threading

Jak wspomniano w tej odpowiedzi , jeśli przechwycisz wynik za pomocą, stdout=a następnie spróbujesz read(), proces zostanie zablokowany.

Są jednak przypadki, w których jest to potrzebne. Na przykład chciałem uruchomić dwa procesy, które rozmawiają przez port między nimi , i zapisać ich stdout w pliku dziennika i stdout.

threadingModuł pozwala nam to zrobić.

Najpierw spójrz na to, jak wykonać część przekierowania wyjścia samodzielnie w tym pytaniu: Python Popen: Zapisuj jednocześnie do standardowego pliku dziennika AND

Następnie:

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()

sleep.py

#!/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)

Po bieganiu:

./main.py

stdout jest aktualizowany co 0,5 sekundy dla każdych dwóch wierszy, które zawierają:

0
10
1
11
2
12
3
13

a każdy plik dziennika zawiera odpowiedni dziennik dla danego procesu.

Inspirowany przez: https://eli.thegreenplace.net/2017/interacting-with-a-long-running-child-process-in-python/

Testowane na Ubuntu 18.04, Python 3.6.7.