Come avviare un processo in background in Python?

Sto cercando di eseguire il porting di uno script di shell sulla versione di Python molto più leggibile. Lo script shell originale avvia diversi processi (utility, monitor, ecc.) In background con "&". Come posso ottenere lo stesso effetto in Python? Vorrei che questi processi non morissero quando gli script di Python sono completi. Sono sicuro che sia in qualche modo legato al concetto di demone, ma non sono riuscito a trovare facilmente questo.

Nota : questa risposta è meno attuale rispetto a quando era stata pubblicata nel 2009. L'utilizzo del subprocessmodulo mostrato in altre risposte è ora raccomandato nei documenti

(Si noti che il modulo di sottoprocesso fornisce strutture più potenti per generare nuovi processi e recuperare i loro risultati; usare quel modulo è preferibile usare queste funzioni.)

Se vuoi che il tuo processo inizi in background puoi usarlo system()e chiamarlo nello stesso modo del tuo script di shell, oppure puoi spawn:

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

(o, in alternativa, puoi provare il os.P_NOWAITflag meno portatile ).

Vedi la documentazione qui .

Mentre la soluzione di jkp funziona, il modo più nuovo di fare le cose (e il modo in cui la documentazione raccomanda) è usaresubprocess modulo. Per comandi semplici è equivalente, ma offre più opzioni se si desidera fare qualcosa di complicato.

Esempio per il tuo caso:

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

Questo verrà eseguito rm -r some.filein background. Si noti che la chiamata .communicate()sull'oggetto restituito da Popenverrà bloccata fino al completamento, quindi non farlo se si desidera che venga eseguito in background:

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

Vedi la documentazione qui .

Inoltre, un punto di chiarimento: "Sfondo" mentre lo usi qui è puramente un concetto di shell; tecnicamente, ciò che vuoi dire è che vuoi generare un processo senza bloccarlo mentre aspetti che venga completato. Tuttavia, ho usato "background" qui per riferirmi a comportamenti di tipo shell-background.

Probabilmente vuoi la risposta a "Come chiamare un comando esterno in Python" .

L'approccio più semplice è utilizzare la os.systemfunzione, ad esempio:

import os
os.system("some_command &")

Fondamentalmente, qualunque cosa passi alla systemfunzione verrà eseguita come se la passassi alla shell in uno script.

L'ho trovato qui :

Su Windows (Win XP), il processo padre non terminerà fino a quando longtask.py avrà terminato il suo lavoro. Non è quello che vuoi in CGI-script. Il problema non è specifico di Python, nella comunità PHP i problemi sono gli stessi.

La soluzione è passare il DETACHED_PROCESS Flag di creazione del processo alla CreateProcessfunzione sottostante nell'API win. Se hai installato pywin32 puoi importare il flag dal modulo win32process, altrimenti dovresti definirlo tu stesso:

DETACHED_PROCESS = 0x00000008

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

Utilizzare subprocess.Popen()con il close_fds=Trueparametro, che consentirà di scollegare il sottoprocesso generato dal processo Python stesso e continuare l'esecuzione anche dopo la chiusura di Python.

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'

Probabilmente si desidera iniziare a studiare il modulo os per il fork di thread diversi (aprendo una sessione interattiva e fornendo aiuto (os)). Le funzioni rilevanti sono fork e ognuna di esse. Per darti un'idea di come iniziare, inserisci qualcosa del genere in una funzione che esegue il fork (la funzione deve prendere un elenco o tuple 'args' come argomento che contiene il nome del programma e i suoi parametri; potresti anche voler per definire stdin, out ed err per il nuovo thread):

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)

Entrambi catturano l'output e vengono eseguiti in background con threading

Come menzionato in questa risposta , se catturi l'output con stdout=e poi provi a read(), il processo si blocca.

Tuttavia, ci sono casi in cui è necessario questo. Ad esempio, volevo avviare due processi che dialogano su una porta tra loro e salvare il loro stdout in un file di registro e stdout.

Il threadingmodulo ci consente di farlo.

Innanzitutto, dai un'occhiata a come eseguire la parte di reindirizzamento dell'output da sola in questa domanda: Python Popen: Scrivi nello stdout e nel file di registro contemporaneamente

Poi:

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)

Dopo l'esecuzione:

./main.py

stdout viene aggiornato ogni 0,5 secondi per contenere ogni due righe:

0
10
1
11
2
12
3
13

e ogni file di registro contiene il rispettivo registro per un determinato processo.

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

Testato su Ubuntu 18.04, Python 3.6.7.