Cara mengakhiri subproses python diluncurkan dengan shell = True

Saya meluncurkan subproses dengan perintah berikut:

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

Namun, ketika saya mencoba membunuh menggunakan:

p.terminate()

atau

p.kill()

Perintah terus berjalan di latar belakang, jadi saya bertanya-tanya bagaimana saya bisa benar-benar menghentikan proses.

Perhatikan bahwa ketika saya menjalankan perintah dengan:

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

Itu berhasil berakhir ketika mengeluarkan p.terminate().

Gunakan grup proses untuk mengaktifkan pengiriman sinyal ke semua proses dalam grup. Untuk itu, Anda harus melampirkan id sesi ke proses induk dari proses spawned / child, yang merupakan shell dalam kasus Anda. Ini akan menjadikannya pemimpin kelompok dalam proses. Jadi sekarang, ketika sinyal dikirim ke pemimpin grup proses, itu dikirim ke semua proses anak dari grup ini.

Ini kodenya:

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()akhirnya membunuh proses shell dan cmdmasih berjalan.

Saya menemukan perbaikan yang mudah dengan:

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

Ini akan menyebabkan cmd mewarisi proses shell, alih-alih membuat shell meluncurkan proses anak, yang tidak terbunuh. p.pidakan menjadi id dari proses cmd Anda.

p.kill() harus bekerja.

Saya tidak tahu apa efek ini pada pipa Anda.

Jika Anda dapat menggunakan psutil , maka ini berfungsi dengan baik:

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)

Saya bisa melakukannya dengan menggunakan

from subprocess import Popen

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

itu membunuh cmd.exedan program yang saya berikan perintah untuk.

(Di Windows)

Ketika shell=Trueshell adalah proses anak, dan perintahnya adalah anak-anaknya. Jadi, ada SIGTERMatau SIGKILLakan membunuh cangkang tetapi tidak proses anaknya, dan saya tidak ingat cara yang baik untuk melakukannya. Cara terbaik yang dapat saya pikirkan adalah menggunakan shell=False, jika tidak ketika Anda membunuh proses shell induk, itu akan meninggalkan proses shell yang mati.

Tidak satu pun dari jawaban ini bekerja untuk saya sehingga saya meninggalkan kode yang berhasil. Dalam kasus saya bahkan setelah membunuh proses dengan .kill()dan mendapatkan .poll()kode kembali proses tersebut tidak berakhir.

Berikut subprocess.Popen dokumentasi :

"... untuk membersihkan aplikasi yang berperilaku baik harus membunuh proses anak dan menyelesaikan komunikasi ..."

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

Dalam kasus saya, saya kehilangan proc.communicate()panggilan setelah proc.kill(). Ini membersihkan proses stdin, stdout ... dan menghentikan proses.

Seperti yang dikatakan Sai, shell adalah anak, jadi sinyal dicegat olehnya - cara terbaik yang saya temukan adalah menggunakan shell = False dan gunakan shlex untuk membagi baris perintah:

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

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

Maka p.kill () dan p.terminate () harus bekerja seperti yang Anda harapkan.

apa yang saya rasa bisa kita gunakan:

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

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

ini tidak akan membunuh semua tugas Anda tetapi proses dengan p.pid

Saya tahu ini adalah pertanyaan lama tetapi ini dapat membantu seseorang mencari metode yang berbeda. Ini yang saya gunakan di windows untuk mematikan proses yang saya panggil.

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

/ IM adalah nama gambar, Anda juga dapat melakukan / PID jika Anda mau. / T membunuh proses serta proses anak. / F force menghentikannya. si, seperti yang saya atur, adalah bagaimana Anda melakukan ini tanpa menunjukkan jendela CMD. Kode ini digunakan dalam python 3.

Kirim sinyal ke semua proses dalam grup

    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)

Saya belum melihat ini disebutkan di sini, jadi saya meletakkannya di sana kalau-kalau seseorang membutuhkannya. Jika yang ingin Anda lakukan adalah memastikan bahwa subproses Anda berakhir dengan sukses, Anda bisa memasukkannya ke dalam manajer konteks. Sebagai contoh, saya ingin printer standar saya untuk mencetak gambar dan menggunakan manajer konteks memastikan bahwa subproses dihentikan.

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...')

Saya percaya metode ini juga lintas platform.