Shell = True ile başlatılan bir python alt işlemini sonlandırma

Aşağıdaki komutla bir alt işlem başlatıyorum:

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

Ancak, kullanarak öldürmeye çalıştığınızda:

p.terminate()

veya

p.kill()

Komut arka planda çalışmaya devam ediyor, bu yüzden süreci nasıl sonlandırabileceğimi merak ediyordum.

Komutu ile çalıştırdığımda:

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

p.terminate(). Verilirken başarıyla sonlandırılır .

Gruplardaki tüm sürece sinyal gönderilmesini sağlamak için bir süreç grubu kullanın . Bunun için , doğmuş / alt süreçlerin üst sürecine, sizin durumunuzda bir kabuk olan bir oturum kimliği eklemelisiniz . Bu onu süreçlerin grup lideri yapacaktır. Şimdi, süreç grubu liderine bir sinyal gönderildiğinde, bu grubun tüm alt süreçlerine iletilir.

İşte kod:

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()kabuk işlemini öldürür ve cmdhala çalışır.

Bu uygun bir düzeltme buldum:

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

Bu, cmd'nin, kabuğun öldürülmeyen bir alt işlemi başlatmasını sağlamak yerine kabuk işlemini miras almasına neden olur. p.pido zaman cmd sürecinizin kimliği olacaktır.

p.kill() çalışmalı.

Bunun borunuz üzerinde ne gibi bir etkisi olacağını bilmiyorum.

Psutil'i kullanabiliyorsanız , bu mükemmel çalışır:

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)

Kullanarak yapabilirdim

from subprocess import Popen

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

cmd.exeve emrini verdiğim programı öldürdü .

(Windows'ta)

Ne zaman shell=Truekabuk çocuk süreçtir ve komutlar onun çocuklarıyız. Yani kabuğu öldürür SIGTERMveya SIGKILLöldürür, ama onun çocuk süreçlerini değil, ve bunu yapmanın iyi bir yolunu hatırlamıyorum. Düşünebileceğim en iyi yol kullanmaktır shell=False, aksi takdirde üst kabuk işlemini öldürdüğünüzde geçersiz bir kabuk işlemi bırakılır .

Bu cevapların hiçbiri benim için çalıştı bu yüzden işe yaradı kod bırakarak. Benim durumumda bile süreci öldürdükten .kill()ve bir .poll()dönüş kodu aldıktan sonra süreç sona ermedi.

subprocess.Popen Belgeleri takip ederek :

"... düzgün bir şekilde temizlemek için iyi davranılmış bir uygulama çocuk sürecini öldürmeli ve iletişimi bitirmelidir ..."

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

Benim durumumda proc.communicate()sonra arama eksikti proc.kill(). Bu işlem stdin, stdout'u temizler ve süreci sonlandırır.

Sai'nin dediği gibi, kabuk çocuktur, bu yüzden sinyaller onun tarafından kesilir - bulduğum en iyi yol shell = False kullanmak ve komut satırını bölmek için shlex kullanmaktır:

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

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

Sonra p.kill () ve p.terminate () beklediğiniz gibi çalışmalıdır.

ne kullanabilirsiniz gibi hissediyorum:

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

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

bu, tüm görevinizi değil, p.pid ile işlemi öldürecektir.

Bunun eski bir soru olduğunu biliyorum ama bu farklı bir yöntem arayan birine yardımcı olabilir. Aradığım işlemleri öldürmek için pencerelerde kullandığım bu.

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

/ IM resim adıdır, isterseniz / PID de yapabilirsiniz. / T süreci ve alt süreçleri öldürür. / F kuvveti onu sonlandırır. si, ayarladığım gibi, bunu bir CMD penceresi göstermeden nasıl yaptığınızdır. Bu kod python 3'te kullanılır.

Sinyali gruptaki tüm süreçlere gönderme

    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)

Burada bahsettiğimi görmedim, bu yüzden birinin ihtiyacı olması durumunda onu dışarıya koyuyorum. Tek yapmanız gereken, alt işleminizin başarıyla sona erdiğinden emin olmaksa, onu bir içerik yöneticisine koyabilirsiniz. Örneğin, standart yazıcımın bir görüntü yazdırmasını ve bağlam yöneticisini kullanarak alt işlemin sonlandırılmasını sağladım.

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

Bu yöntemin de platformlar arası olduğuna inanıyorum.