मैं निम्नलिखित कमांड के साथ एक उपप्रकार ला रहा हूं:
p = subprocess.Popen(cmd, stdout=subprocess.PIPE, shell=True)हालांकि, जब मैं का उपयोग कर मारने की कोशिश:
p.terminate()या
p.kill()आदेश पृष्ठभूमि में चलता रहता है, इसलिए मैं सोच रहा था कि मैं वास्तव में इस प्रक्रिया को कैसे समाप्त कर सकता हूं।
ध्यान दें कि जब मैं कमांड चलाता हूं:
p = subprocess.Popen(cmd.split(), stdout=subprocess.PIPE)यह जारी करते समय सफलतापूर्वक समाप्त होता है p.terminate()।
shell=Trueबड़ा फर्क नहीं पड़ता?
जवाबों:
एक प्रक्रिया समूह का उपयोग करें ताकि समूहों में सभी प्रक्रिया को संकेत भेजने में सक्षम किया जा सके। उसके लिए, आपको स्पॉन्स्ड / चाइल्ड प्रोसेस की मूल प्रक्रिया के लिए एक सेशन आईडी संलग्न करना चाहिए , जो आपके मामले में एक शेल है। यह इसे प्रक्रियाओं का समूह नेता बनाएगा। तो अब, जब एक संकेत प्रक्रिया समूह के नेता को भेजा जाता है, तो यह इस समूह की सभी बाल प्रक्रियाओं में प्रसारित हो जाता है।
यहाँ कोड है:
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 groupsos.setsidविंडोज़ में उपलब्ध नहीं है ( docs.python.org/library/os.html#os.setsid ), मुझे नहीं पता कि यह मदद कर सकता है लेकिन आप यहां देख सकते हैं ( bugs.python.org) / जारी करने के लिए कैसे के बारे में कुछ अंतर्दृष्टि के लिए)।
subprocess.CREATE_NEW_PROCESS_GROUPसंबंधित है?
p = subprocess.Popen(cmd, stdout=subprocess.PIPE, shell=True)
p.kill()p.kill() खोल प्रक्रिया को मारने और cmd अभी भी चल रहा है।
मुझे इससे एक सुविधाजनक फ़िक्स मिला:
p = subprocess.Popen("exec " + cmd, stdout=subprocess.PIPE, shell=True)यह cmd को शेल प्रक्रिया को इनहेरिट करने का कारण बनेगा, बजाय इसके कि शेल लॉन्च एक चाइल्ड प्रोसेस है, जो कि मारा नहीं जाता है। p.pidतब आपके cmd प्रोसेस की id होगी।
p.kill() कार्य करना चाहिए।
मुझे नहीं पता कि आपके पाइप पर इसका क्या प्रभाव पड़ेगा।
यदि आप psutil का उपयोग कर सकते हैं , तो यह पूरी तरह से काम करता है:
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)AttributeError: 'Process' object has no attribute 'get_childrenके लिए pip install psutil।
मैं इसका उपयोग कर सकता है
from subprocess import Popen
process = Popen(command, shell=True)
Popen("TASKKILL /F /PID {pid} /T".format(pid=process.pid))इसने cmd.exeउस कार्यक्रम को मार दिया, जिसके लिए मैंने आज्ञा दी थी।
(विंडोज पर)
Popen("TASKKILL /F /IM " + process_name)यदि आपके पास यह नहीं है, तो आप इसे commandपैरामीटर से प्राप्त कर सकते हैं ।
जब shell=Trueशेल बाल प्रक्रिया है, और कमांड इसके बच्चे हैं। किसी भी तो SIGTERMया SIGKILLखोल मार डालेगा करती है लेकिन उसके बच्चे प्रक्रियाओं, और मैं एक अच्छा तरीका यह करने के लिए याद नहीं है। सबसे अच्छा तरीका मैं सोच सकता हूं कि इसका उपयोग करना है shell=False, अन्यथा जब आप मूल शेल प्रक्रिया को मारते हैं, तो यह एक दोषपूर्ण शेल प्रक्रिया को छोड़ देगा।
इस जवाब में से किसी ने मेरे लिए काम नहीं किया इसलिए इम ने उस कोड को छोड़ दिया जिसने काम किया। मेरे मामले में भी इस प्रक्रिया को मारने .kill()और .poll()रिटर्न कोड प्राप्त करने के बाद प्रक्रिया समाप्त नहीं हुई।
subprocess.Popen प्रलेखन के बाद :
"... ठीक से व्यवहार करने के लिए एक अच्छी तरह से व्यवहार किए गए एप्लिकेशन को बच्चे की प्रक्रिया को मारना चाहिए और संचार समाप्त करना चाहिए ..."
proc = subprocess.Popen(...)
try:
outs, errs = proc.communicate(timeout=15)
except TimeoutExpired:
proc.kill()
outs, errs = proc.communicate()मेरे मामले में मैं proc.communicate()फोन करने के बाद गायब था proc.kill()। यह प्रक्रिया स्टड, स्टडआउट को साफ करता है ... और प्रक्रिया को समाप्त करता है।
जैसा कि साई ने कहा, शेल बच्चा है, इसलिए संकेतों को इसके द्वारा इंटरसेप्ट किया जाता है - मैंने पाया सबसे अच्छा तरीका शेल = गलत का उपयोग करना और कमांड लाइन को विभाजित करने के लिए श्लेक्स का उपयोग करना है:
if isinstance(command, unicode):
cmd = command.encode('utf8')
args = shlex.split(cmd)
p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)तब p.kill () और p.terminate () को वह कार्य करना चाहिए जो आप अपेक्षा करते हैं।
cwdतर्क को पास करो Popen।
मुझे पता है कि यह एक पुराना सवाल है लेकिन इससे किसी को अलग तरीके की तलाश करने में मदद मिल सकती है। यह वही है जो मैंने विंडोज़ पर उपयोग की जाने वाली प्रक्रियाओं को मारने के लिए उपयोग किया है।
si = subprocess.STARTUPINFO()
si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
subprocess.call(["taskkill", "/IM", "robocopy.exe", "/T", "/F"], startupinfo=si)/ IM छवि का नाम है, आप चाहें तो PID भी कर सकते हैं। / टी प्रक्रिया को मारता है और साथ ही बच्चे को भी प्रक्रिया करता है। / एफ बल इसे समाप्त करता है। सी, जैसा कि मैंने इसे सेट किया है, सीएमडी विंडो दिखाए बिना आप यह कैसे करते हैं। इस कोड का उपयोग अजगर 3 में किया जाता है।
समूह में सभी प्रक्रियाओं के लिए संकेत भेजें
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)मैंने इस उल्लेख को यहाँ नहीं देखा है, इसलिए मैं इसे वहाँ रख रहा हूँ जब किसी को इसकी आवश्यकता हो। यदि आप सभी को यह सुनिश्चित करना है कि आपका उपप्रकार सफलतापूर्वक समाप्त हो जाए, तो आप इसे एक संदर्भ प्रबंधक में रख सकते हैं। उदाहरण के लिए, मैं चाहता था कि मेरा मानक प्रिंटर एक छवि को प्रिंट करे और संदर्भ प्रबंधक का उपयोग करके सुनिश्चित करे कि उपप्रोसेस समाप्त हो गया।
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...')मेरा मानना है कि यह तरीका क्रॉस-प्लेटफॉर्म भी है।
shell=Trueप्रश्न के अनुसार प्रक्रिया शुरू की जाती है ? यह आपके कोड में नहीं है।
thread.join()। आशा है कि यह इसे साफ करता है।
cmdलुक कैसा है? इसमें एक कमांड हो सकती है जो शुरू होने वाली कई प्रक्रियाओं को ट्रिगर करती है। इसलिए यह स्पष्ट नहीं है कि आप किस प्रक्रिया के बारे में बात करते हैं।