Como iniciar um processo em segundo plano no Python?

Estou tentando portar um script de shell para a versão python muito mais legível. O script shell original inicia vários processos (utilitários, monitores, etc.) em segundo plano com "&". Como posso obter o mesmo efeito em python? Eu gostaria que esses processos não morressem quando os scripts python forem concluídos. Tenho certeza de que está relacionado ao conceito de um daemon de alguma forma, mas não consegui descobrir como fazer isso facilmente.

Nota : esta resposta é menos atual do que era quando postada em 2009. O uso do subprocessmódulo mostrado em outras respostas agora é recomendado nos documentos

(Observe que o módulo de subprocesso fornece recursos mais poderosos para gerar novos processos e recuperar seus resultados; usar esse módulo é preferível a usar essas funções.)

Se você deseja que seu processo inicie em segundo plano, você pode usá system()-lo e chamá-lo da mesma maneira que seu script shell, ou você pode spawn:

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

(ou, alternativamente, você pode tentar o os.P_NOWAITsinalizador menos portátil ).

Veja a documentação aqui .

Enquanto a solução da jkp funciona, a maneira mais nova de fazer as coisas (e a maneira como a documentação recomenda) é usar o subprocessmódulo. Para comandos simples é equivalente, mas oferece mais opções se você quiser fazer algo complicado.

Exemplo para o seu caso:

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

Isso será executado rm -r some.fileem segundo plano. Observe que a chamada .communicate()do objeto retornado Popenserá bloqueada até que seja concluída, portanto, não faça isso se quiser que ele seja executado em segundo plano:

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

Consulte a documentação aqui .

Além disso, um ponto de esclarecimento: "Antecedentes", como você os utiliza aqui, é puramente um conceito de shell; tecnicamente, o que você quer dizer é que deseja gerar um processo sem bloquear enquanto espera que ele seja concluído. No entanto, usei "background" aqui para se referir ao comportamento semelhante ao do shell.

Você provavelmente deseja a resposta para "Como chamar um comando externo em Python" .

A abordagem mais simples é usar a os.systemfunção, por exemplo:

import os
os.system("some_command &")

Basicamente, tudo o que você passar para a systemfunção será executado da mesma forma como se você a tivesse passado para o shell em um script.

Encontrei isso aqui :

No windows (win xp), o processo pai não será concluído até que o trabalho longtask.pyseja concluído. Não é o que você deseja no script CGI. O problema não é específico do Python, na comunidade PHP os problemas são os mesmos.

A solução é passar o DETACHED_PROCESS Sinalizador de criação de processo para a CreateProcessfunção subjacente na API do win. Se você instalou o pywin32, pode importar o sinalizador do módulo win32process, caso contrário, você deve defini-lo:

DETACHED_PROCESS = 0x00000008

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

Use subprocess.Popen()com o close_fds=Trueparâmetro, que permitirá que o subprocesso gerado seja desconectado do próprio processo Python e continue em execução mesmo após a saída do 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'

Você provavelmente deseja começar a investigar o módulo os para criar bifurcações diferentes (abrindo uma sessão interativa e emitindo ajuda (os)). As funções relevantes são fork e qualquer uma das exec. Para lhe dar uma idéia de como iniciar, coloque algo como isto em uma função que executa o fork (a função precisa usar uma lista ou tupla 'args' como um argumento que contenha o nome do programa e seus parâmetros; você também pode querer para definir stdin, out e err para o novo 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)

Capture a saída e execute em segundo plano com threading

Conforme mencionado nesta resposta , se você capturar a saída com stdout=e depois tentar read(), o processo será bloqueado.

No entanto, há casos em que você precisa disso. Por exemplo, eu queria iniciar dois processos que conversam sobre uma porta entre eles e salvar o stdout em um arquivo de log e stdout.

O threadingmódulo nos permite fazer isso.

Primeiro, veja como fazer a parte do redirecionamento de saída sozinha nesta pergunta: Python Popen: Escreva no stdout AND no arquivo de log simultaneamente

Então:

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)

Depois de correr:

./main.py

O stdout é atualizado a cada 0,5 segundos para que cada duas linhas contenha:

0
10
1
11
2
12
3
13

e cada arquivo de log contém o respectivo log para um determinado processo.

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

Testado no Ubuntu 18.04, Python 3.6.7.