So beenden Sie einen Python-Unterprozess, der mit shell = True gestartet wurde

Ich starte einen Unterprozess mit dem folgenden Befehl:

p = subprocess.Popen(cmd, stdout=subprocess.PIPE, shell=True)

Wenn ich jedoch versuche zu töten mit:

p.terminate()

oder

p.kill()

Der Befehl wird weiterhin im Hintergrund ausgeführt, daher habe ich mich gefragt, wie ich den Prozess tatsächlich beenden kann.

Beachten Sie Folgendes, wenn ich den Befehl ausführe mit:

p = subprocess.Popen(cmd.split(), stdout=subprocess.PIPE)

Es wird erfolgreich beendet, wenn das ausgegeben wird p.terminate().

Verwenden Sie eine Prozessgruppe , um das Senden eines Signals an alle Prozesse in den Gruppen zu ermöglichen. Dazu sollten Sie dem übergeordneten Prozess der erzeugten / untergeordneten Prozesse eine Sitzungs-ID hinzufügen, die in Ihrem Fall eine Shell ist. Dies macht es zum Gruppenleiter der Prozesse. Wenn nun ein Signal an den Prozessgruppenleiter gesendet wird, wird es an alle untergeordneten Prozesse dieser Gruppe übertragen.

Hier ist der Code:

import os
import signal
import subprocess

# The os.setsid() is passed in the argument preexec_fn so
# it's run after the fork() and before  exec() to run the shell.
pro = subprocess.Popen(cmd, stdout=subprocess.PIPE, 
                       shell=True, preexec_fn=os.setsid) 

os.killpg(os.getpgid(pro.pid), signal.SIGTERM)  # Send the signal to all the process groups

p = subprocess.Popen(cmd, stdout=subprocess.PIPE, shell=True)
p.kill()

p.kill()beendet den Shell-Prozess und cmdläuft noch.

Ich fand eine bequeme Lösung, indem ich:

p = subprocess.Popen("exec " + cmd, stdout=subprocess.PIPE, shell=True)

Dies führt dazu, dass cmd den Shell-Prozess erbt, anstatt dass die Shell einen untergeordneten Prozess startet, der nicht beendet wird. p.pidwird dann die ID Ihres cmd-Prozesses sein.

p.kill() sollte arbeiten.

Ich weiß allerdings nicht, welche Auswirkungen dies auf Ihre Pfeife haben wird.

Wenn Sie Psutil verwenden können , funktioniert dies perfekt:

import subprocess

import psutil


def kill(proc_pid):
    process = psutil.Process(proc_pid)
    for proc in process.children(recursive=True):
        proc.kill()
    process.kill()


proc = subprocess.Popen(["infinite_app", "param"], shell=True)
try:
    proc.wait(timeout=3)
except subprocess.TimeoutExpired:
    kill(proc.pid)

Ich könnte es mit tun

from subprocess import Popen

process = Popen(command, shell=True)
Popen("TASKKILL /F /PID {pid} /T".format(pid=process.pid))

es tötete das cmd.exeund das Programm, für das ich den Befehl gab.

(Unter Windows)

Wenn shell=Truedie Shell der untergeordnete Prozess ist und die Befehle ihre untergeordneten Prozesse sind. Also jeder SIGTERModer SIGKILLwird die Shell töten, aber nicht ihre untergeordneten Prozesse, und ich erinnere mich nicht an einen guten Weg, dies zu tun. Der beste Weg, den ich mir vorstellen kann, ist die Verwendung shell=False. Andernfalls wird beim Beenden des übergeordneten Shell-Prozesses ein nicht mehr funktionierender Shell-Prozess zurückgelassen.

Keine dieser Antworten hat bei mir funktioniert, also lasse ich den Code, der funktioniert hat. In meinem Fall wurde der Prozess auch nach dem Beenden des Prozesses mit .kill()und dem Abrufen eines .poll()Rückkehrcodes nicht beendet.

Befolgen Sie die subprocess.Popen Dokumentation :

"... um eine ordnungsgemäße Bereinigung zu erreichen, sollte eine gut erzogene Anwendung den untergeordneten Prozess beenden und die Kommunikation beenden ..."

proc = subprocess.Popen(...)
try:
    outs, errs = proc.communicate(timeout=15)
except TimeoutExpired:
    proc.kill()
    outs, errs = proc.communicate()

In meinem Fall fehlte mir das proc.communicate()nach dem Anruf proc.kill(). Dies bereinigt den Prozess stdin, stdout ... und beendet den Prozess.

Wie Sai sagte, ist die Shell das Kind, also werden Signale von ihr abgefangen - der beste Weg, den ich gefunden habe, ist Shell = False zu verwenden und Shlex zu verwenden, um die Befehlszeile zu teilen:

if isinstance(command, unicode):
    cmd = command.encode('utf8')
args = shlex.split(cmd)

p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

Dann sollten p.kill () und p.terminate () so funktionieren, wie Sie es erwarten.

Wie ich denke, könnten wir gebrauchen:

import os
import signal
import subprocess
p = subprocess.Popen(cmd, stdout=subprocess.PIPE, shell=True)

os.killpg(os.getpgid(pro.pid), signal.SIGINT)

Dies wird nicht alle Ihre Aufgaben beenden, sondern den Prozess mit der p.pid

Ich weiß, dass dies eine alte Frage ist, aber dies kann jemandem helfen, der nach einer anderen Methode sucht. Dies ist, was ich unter Windows verwende, um Prozesse abzubrechen, die ich aufgerufen habe.

si = subprocess.STARTUPINFO()
si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
subprocess.call(["taskkill", "/IM", "robocopy.exe", "/T", "/F"], startupinfo=si)

/ IM ist der Bildname, Sie können auch / PID ausführen, wenn Sie möchten. / T beendet den Prozess sowie die untergeordneten Prozesse. / F Kraft beendet es. si, wie ich es eingestellt habe, ist, wie Sie dies tun, ohne ein CMD-Fenster anzuzeigen. Dieser Code wird in Python 3 verwendet.

Senden Sie das Signal an alle Prozesse in der Gruppe

    self.proc = Popen(commands, 
            stdout=PIPE, 
            stderr=STDOUT, 
            universal_newlines=True, 
            preexec_fn=os.setsid)

    os.killpg(os.getpgid(self.proc.pid), signal.SIGHUP)
    os.killpg(os.getpgid(self.proc.pid), signal.SIGTERM)

Ich habe dies hier nicht erwähnt gesehen, also stelle ich es dort heraus, falls jemand es braucht. Wenn Sie lediglich sicherstellen möchten, dass Ihr Unterprozess erfolgreich beendet wird, können Sie ihn in einen Kontextmanager einfügen. Ich wollte beispielsweise, dass mein Standarddrucker ein ausgedrucktes Bild druckt und mithilfe des Kontextmanagers sicherstellt, dass der Unterprozess beendet wird.

import subprocess

with open(filename,'rb') as f:
    img=f.read()
with subprocess.Popen("/usr/bin/lpr", stdin=subprocess.PIPE) as lpr:
    lpr.stdin.write(img)
print('Printed image...')

Ich glaube, diese Methode ist auch plattformübergreifend.