दिलचस्प पोस्ट
MATLAB में, मैं एक छवि को कैसे साजिश कर सकता हूं और इसे प्रदर्शित किए बिना परिणाम सहेज सकता हूं? बाकी बनाम JSON-RPC? स्ट्रिंग्स के एक सेट में सबसे लंबे समय तक सामान्य शुरू करने वाले स्थान का पता लगाएं जीआईटी में क्या मतलब है? एंड्रॉइड साझा वरीयता मान के लिए अधिकतम आकार क्या है? UITableView में IOS दस्तावेज़ निर्देशिका में सहेजी गई फ़ाइलों की सूची? जावा कॉन्स्टेंट पूल का उद्देश्य क्या है? आप एक जेवीएम कैसे क्रैश करते हैं? क्या MySQL ऐतिहासिक तारीख का समर्थन करता है (जैसे 1200)? जावा कोड के कुछ वर्गों के लिए एक्लिप्स कोड फॉर्मेटर कैसे बंद करें? वॉली का उपयोग करते हुए JSON डेटा के साथ पोस्ट अनुरोध भेजें के लिए __gxx_personality_v0 क्या है? array_key_exists काम नहीं कर रहा है क्यों अस्थिर क्वालिफायर बाहर std :: परमाणु के माध्यम से इस्तेमाल किया है? phpmyadmin स्वत: लॉगआउट समय

सभी बाल प्रक्रियाओं को मारने का सर्वोत्तम तरीका

मैं पूरी प्रक्रिया के पेड़ को मारना चाहता हूं यह किसी भी आम स्क्रिप्टिंग भाषाओं का उपयोग करने का सबसे अच्छा तरीका क्या है? मैं एक सरल समाधान की तलाश कर रहा हूं

Solutions Collecting From Web of "सभी बाल प्रक्रियाओं को मारने का सर्वोत्तम तरीका"

आप यह नहीं कहते हैं कि यदि आप जिस पेड़ को मारना चाहते हैं वह एक एकल प्रक्रिया समूह है। (यह अक्सर मामला होता है यदि पेड़ एक सर्वर प्रारंभ या शेल कमांड लाइन से फर्क करने का नतीजा है।) आप निम्न के रूप में जीएनयू पीएस का उपयोग कर प्रक्रिया समूह की खोज कर सकते हैं:

  ps x -o "%p %r %y %x %c " 

यदि यह एक प्रक्रिया समूह है जिसे आप मारना चाहते हैं, तो kill(1) कमांड का प्रयोग करें, लेकिन इसे एक प्रोसेस नंबर देने के बजाय, समूह संख्या का नकारा दे। उदाहरण के लिए समूह 5112 में हर प्रक्रिया को मारने के लिए, kill -TERM -- -5112 उपयोग करें

प्रोसेस ग्रुप आईडी ( PGID ) का उपयोग करते हुए एक ही प्रक्रिया पेड़ से संबंधित सभी प्रक्रियाओं को मार डालो

  • kill -- -$PGID डिफ़ॉल्ट संकेत का उपयोग करें ( TERM = 15)
  • kill -9 -$PGID सिग्नल का उपयोग करें (9)

आप उसी प्रक्रिया पेड़ के किसी भी प्रोसेस-आईडी ( PID ) से PGID पुनः प्राप्त कर सकते हैं

  • kill -- -$(ps -o pgid= $PID | grep -o '[0-9]*') (संकेत TERM )
  • kill -9 -$(ps -o pgid= $PID | grep -o '[0-9]*') (सिग्नल KILL )

$PID शेष रिक्त स्थान और OSX संगतता पर योगदान के लिए tanager और Speakus के लिए विशेष धन्यवाद।

व्याख्या

  • kill -9 -"$PGID" => सभी बच्चे और पोते को सिग्नल 9 ( kill -9 -"$PGID" ) भेजें …
  • PGID=$(ps opgid= "$PID") => PGID=$(ps opgid= "$PID") किसी भी प्रोसेस-आईडी से प्रोसेस-ग्रुप-आईडी पुनर्प्राप्त करें, न केवल प्रोसेस-पेरेंट-आईडी ps opgid= $PID की एक भिन्नता ps -o pgid --no-headers $PID जहां pgid को pgrp द्वारा प्रतिस्थापित किया जा सकता है।
    परंतु:
    • ps रिक्त स्थान के शीर्ष स्थान पर स्थित है, जब PID पांच अंकों से कम है और दाएं गठबंधन के रूप में tanager द्वारा देखा गया है। आप उपयोग कर सकते हैं:
      PGID=$(ps opgid= "$PID" | tr -d ' ')
    • OSX से ps हमेशा हेडर प्रिंट करता है, इसलिए स्पीकस का प्रस्ताव है:
      PGID="$( ps -o pgid "$PID" | grep [0-9] | tr -d ' ' )"
  • grep -o [0-9]* लगातार अंक प्रिंट करता है (रिक्त स्थान या वर्णानुक्रमिक हेडर प्रिंट नहीं करता है)।

आगे कमांड लाइनें

 PGID=$(ps -o pgid= $PID | grep -o [0-9]*) kill -TERM -"$PGID" # kill -15 kill -INT -"$PGID" # correspond to [CRTL+C] from keyboard kill -QUIT -"$PGID" # correspond to [CRTL+\] from keyboard kill -CONT -"$PGID" # restart a stopped process (above signals do not kill it) sleep 2 # wait terminate process (more time if required) kill -KILL -"$PGID" # kill -9 if it does not intercept signals (or buggy) 

सीमा

  • जैसा कि डावाइड और ह्यूबर्ट करियो द्वारा देखा जाता है, जब एक ही वृक्ष से संबंधित प्रक्रिया द्वारा kill जाता है, तो पूरे पेड़ की हत्या को खत्म करने से पहले खुद को मारने के जोखिम को मार डालो।
  • इसलिए, एक भिन्न प्रक्रिया-समूह-आईडी वाली प्रक्रिया का उपयोग करके कमांड चलाने को सुनिश्चित करें

लम्बी कहानी

 > cat run-many-processes.sh #!/bin/sh echo "ProcessID=$$ begins ($0)" ./child.sh background & ./child.sh foreground echo "ProcessID=$$ ends ($0)" > cat child.sh #!/bin/sh echo "ProcessID=$$ begins ($0)" ./grandchild.sh background & ./grandchild.sh foreground echo "ProcessID=$$ ends ($0)" > cat grandchild.sh #!/bin/sh echo "ProcessID=$$ begins ($0)" sleep 9999 echo "ProcessID=$$ ends ($0)" 

'&' का उपयोग करके पृष्ठभूमि में प्रक्रिया का पेड़ चलाएं

 > ./run-many-processes.sh & ProcessID=28957 begins (./run-many-processes.sh) ProcessID=28959 begins (./child.sh) ProcessID=28958 begins (./child.sh) ProcessID=28960 begins (./grandchild.sh) ProcessID=28961 begins (./grandchild.sh) ProcessID=28962 begins (./grandchild.sh) ProcessID=28963 begins (./grandchild.sh) > PID=$! # get the Parent Process ID > PGID=$(ps opgid= "$PID") # get the Process Group ID > ps fj PPID PID PGID SID TTY TPGID STAT UID TIME COMMAND 28348 28349 28349 28349 pts/3 28969 Ss 33021 0:00 -bash 28349 28957 28957 28349 pts/3 28969 S 33021 0:00 \_ /bin/sh ./run-many-processes.sh 28957 28958 28957 28349 pts/3 28969 S 33021 0:00 | \_ /bin/sh ./child.sh background 28958 28961 28957 28349 pts/3 28969 S 33021 0:00 | | \_ /bin/sh ./grandchild.sh background 28961 28965 28957 28349 pts/3 28969 S 33021 0:00 | | | \_ sleep 9999 28958 28963 28957 28349 pts/3 28969 S 33021 0:00 | | \_ /bin/sh ./grandchild.sh foreground 28963 28967 28957 28349 pts/3 28969 S 33021 0:00 | | \_ sleep 9999 28957 28959 28957 28349 pts/3 28969 S 33021 0:00 | \_ /bin/sh ./child.sh foreground 28959 28960 28957 28349 pts/3 28969 S 33021 0:00 | \_ /bin/sh ./grandchild.sh background 28960 28964 28957 28349 pts/3 28969 S 33021 0:00 | | \_ sleep 9999 28959 28962 28957 28349 pts/3 28969 S 33021 0:00 | \_ /bin/sh ./grandchild.sh foreground 28962 28966 28957 28349 pts/3 28969 S 33021 0:00 | \_ sleep 9999 28349 28969 28969 28349 pts/3 28969 R+ 33021 0:00 \_ ps fj 

कमांड pkill -P $PID पोते को नहीं मारती:

 > pkill -P "$PID" ./run-many-processes.sh: line 4: 28958 Terminated ./child.sh background ./run-many-processes.sh: line 4: 28959 Terminated ./child.sh foreground ProcessID=28957 ends (./run-many-processes.sh) [1]+ Done ./run-many-processes.sh > ps fj PPID PID PGID SID TTY TPGID STAT UID TIME COMMAND 28348 28349 28349 28349 pts/3 28987 Ss 33021 0:00 -bash 28349 28987 28987 28349 pts/3 28987 R+ 33021 0:00 \_ ps fj 1 28963 28957 28349 pts/3 28987 S 33021 0:00 /bin/sh ./grandchild.sh foreground 28963 28967 28957 28349 pts/3 28987 S 33021 0:00 \_ sleep 9999 1 28962 28957 28349 pts/3 28987 S 33021 0:00 /bin/sh ./grandchild.sh foreground 28962 28966 28957 28349 pts/3 28987 S 33021 0:00 \_ sleep 9999 1 28961 28957 28349 pts/3 28987 S 33021 0:00 /bin/sh ./grandchild.sh background 28961 28965 28957 28349 pts/3 28987 S 33021 0:00 \_ sleep 9999 1 28960 28957 28349 pts/3 28987 S 33021 0:00 /bin/sh ./grandchild.sh background 28960 28964 28957 28349 pts/3 28987 S 33021 0:00 \_ sleep 9999 

कमांड kill -- -$PGID नाती-पोते सहित सभी प्रक्रियाओं को मारता है।

 > kill -- -"$PGID" # default signal is TERM (kill -15) > kill -CONT -"$PGID" # awake stopped processes > kill -KILL -"$PGID" # kill -9 to be sure > ps fj PPID PID PGID SID TTY TPGID STAT UID TIME COMMAND 28348 28349 28349 28349 pts/3 29039 Ss 33021 0:00 -bash 28349 29039 29039 28349 pts/3 29039 R+ 33021 0:00 \_ ps fj 

निष्कर्ष

मैं इस उदाहरण में नोटिस PID और PGID बराबर ( 28957 9 28957 ) है।
यही कारण है कि मैं मूल रूप से सोचा था kill -- -$PID पर्याप्त था लेकिन इस मामले में प्रक्रिया मेकफाइल के भीतर पैदा होती है, प्रक्रिया आईडी समूह आईडी से अलग होती है।

मुझे लगता है कि kill -- -$(ps -o pgid= $PID | grep -o [0-9]*) एक अलग समूह आईडी (एक अन्य प्रक्रिया पेड़) से कहा जाता है जब एक पूरी प्रक्रिया पेड़ को मारने के लिए सबसे अच्छी सरल चाल है।

 pkill -TERM -P 27888 

यह सभी प्रक्रियाओं को मार देगा जो कि माता पिता की प्रक्रिया आईडी 27888 है।

या अधिक मजबूत:

 CPIDS=$(pgrep -P 27888); (sleep 33 && kill -KILL $CPIDS &); kill -TERM $CPIDS 

जो बाद में 33 सेकंड की हत्या कर रहा है और विनम्रतापूर्वक समाप्त करने के लिए प्रक्रियाओं को पूछता है।

सभी वंश को समाप्त करने के लिए इस उत्तर देखें

एक प्रक्रिया पेड़ को लगातार मारने के लिए, killtree () का उपयोग करें:

 #!/bin/bash killtree() { local _pid=$1 local _sig=${2:--TERM} kill -stop ${_pid} # needed to stop quickly forking parent from producing children between child killing and parent killing for _child in $(ps -o pid --no-headers --ppid ${_pid}); do killtree ${_child} ${_sig} done kill -${_sig} ${_pid} } if [ $# -eq 0 -o $# -gt 2 ]; then echo "Usage: $(basename $0) <pid> [signal]" exit 1 fi killtree $@ 

ब्रैड का उत्तर यही है कि मैं भी --ppid , सिवाय इसके कि आप awk साथ पूरी तरह से दूर कर awk अगर आप --ppid को --ppid विकल्प का उपयोग करते हैं।

 for child in $(ps -o pid -ax --ppid $PPID) do ....... done 

यदि आप जानते हैं कि मूल प्रक्रिया के pid को पास करें, यहां एक शेल स्क्रिप्ट है जिसे काम करना चाहिए:

 for child in $(ps -o pid,ppid -ax | \ awk "{ if ( \$2 == $pid ) { print \$1 }}") do echo "Killing child process $child because ppid = $pid" kill $child done 

मैं यहाँ वर्णित विधि के थोड़ा संशोधित संस्करण का उपयोग करता हूं: https://stackoverflow.com/a/5311362/563175

तो ऐसा लगता है कि:

 kill `pstree -p 24901 | sed 's/(/\n(/g' | grep '(' | sed 's/(\(.*\)).*/\1/' | tr "\n" " "` 

जहां 24 9 01 माता-पिता की पीआईडी ​​है

यह बहुत बदसूरत लग रहा है लेकिन यह पूरी तरह से काम करता है

झीगांग के जवाब का संशोधित संस्करण:

 #!/usr/bin/env bash set -eu killtree() { local pid for pid; do kill -stop $pid local cpid for cpid in $(pgrep -P $pid); do killtree $cpid done kill $pid kill -cont $pid wait $pid 2>/dev/null || true done } cpids() { local pid=$1 options=${2:-} space=${3:-} local cpid for cpid in $(pgrep -P $pid); do echo "$space$cpid" if [[ "${options/a/}" != "$options" ]]; then cpids $cpid "$options" "$space " fi done } while true; do sleep 1; done & cpid=$! for i in $(seq 1 2); do cpids $$ a sleep 1 done killtree $cpid echo --- cpids $$ a 

नोर्मन रैमसे के उत्तर में जोड़ने के लिए, यदि आप एक प्रोसेस ग्रुप बनाना चाहते हैं, तो सेटिड पर दिखने के लायक हो सकता है।
http://pubs.opengroup.org/onlinepubs/009695399/functions/setsid.html

सेटिड () फ़ंक्शन एक नया सत्र बनाएगा, अगर कॉलिंग प्रोसेस ग्रुप लीडर नहीं है। वापसी पर कॉलिंग प्रक्रिया इस नए सत्र का सत्र नेता होगा, एक नई प्रक्रिया समूह की प्रक्रिया समूह का नेता होगा, और कोई नियंत्रण टर्मिनल नहीं होगा। कॉलिंग प्रक्रिया की प्रक्रिया समूह आईडी को कॉलिंग प्रक्रिया की प्रक्रिया आईडी के बराबर सेट किया जाएगा। कॉलिंग प्रक्रिया नई प्रक्रिया समूह में एकमात्र प्रक्रिया होगी और नए सत्र में एकमात्र प्रक्रिया होगी।

जो मेरा मतलब है कि आप आरंभिक प्रक्रिया से एक समूह बना सकते हैं। मैंने इसे php में इस्तेमाल किया ताकि इसे शुरू करने के बाद पूरी प्रक्रिया के पेड़ को मारने में सक्षम हो।

यह एक बुरा विचार हो सकता है मुझे टिप्पणियों में दिलचस्पी होगी

मैं टिप्पणी नहीं कर सकता (पर्याप्त प्रतिष्ठा नहीं), इसलिए मुझे एक नया जवाब जोड़ने के लिए मजबूर होना है, हालांकि यह वास्तव में एक जवाब नहीं है।

28 फरवरी को @लिब्रे द्वारा दिए गए अन्यथा बहुत अच्छे और पूर्ण उत्तर के साथ थोड़ी समस्या है। ps opgid= $PID का आउटपुट पांच अंक से कम पीआईडी ​​के लिए प्रमुख स्थान रखता है क्योंकि ps कॉलम को उचित ठहराना है संख्या)। संपूर्ण कमांड लाइन के भीतर, यह एक नकारात्मक संकेत, जिसके बाद स्थान पीआईडी ​​द्वारा पीछा किया जाता है। रिक्त स्थान को हटाने के लिए सरल समाधान पाइप ps से होता है:

 kill -- -$( ps opgid= $PID | tr -d ' ' ) 

pslc पैकेज से rkill कमांड विशिष्ट प्रक्रिया और उसके सभी वंशों को दिए गए संकेत (या डिफ़ॉल्ट रूप से SIGTERM ) भेजता है:

 rkill [-SIG] pid/name... 

Ysth की टिप्पणी से प्रेरित होकर

 kill -- -PGID 

इसे एक प्रोसेस नंबर देने के बजाय, समूह संख्या का नकारा दे। लगभग किसी भी कमांड के साथ हमेशा की तरह, यदि आप एक सामान्य तर्क चाहते हैं जो एक के साथ शुरू होता है - स्विच के रूप में व्याख्या नहीं किया जाता है, इसके साथ पहले --

निम्न शेल फ़ंक्शन अन्य अन्य उत्तरों के समान है, लेकिन यह बाहरी निर्भरता जैसे pgrep बिना लिनक्स और बीएसडी (ओएस एक्स आदि) दोनों पर काम करता है:

 killtree() { local parent=$1 child for child in $(ps -o ppid= -o pid= | awk "\$1==$parent {print \$2}"); do killtree $child done kill $parent } 

इसे psutil का उपयोग करके अजगर के साथ ऐसा करना आसान है बस पीओपी के साथ psutil स्थापित करें और फिर आपके पास प्रक्रिया हेरफेर टूल का पूरा सूट है:

 def killChildren(pid): parent = psutil.Process(pid) for child in parent.get_children(True): if child.is_running(): child.terminate() 

झीगांग के उत्तर के आधार पर, यह आत्म-हत्या से बचा जाता है:

 init_killtree() { local pid=$1 child for child in $(pgrep -P $pid); do init_killtree $child done [ $pid -ne $$ ] && kill -kill $pid } 

यदि आप नाम से प्रक्रिया को मारना चाहते हैं:

 killall -9 -g someprocessname 

या

 pgrep someprocessname | xargs pkill -9 -g 

यह बाश स्क्रिप्ट का इस्तेमाल करते हुए सभी बच्चे की प्रक्रियाओं को मारने का मेरा संस्करण है। यह पुनरावर्ती का उपयोग नहीं करता है और pgrep कमांड पर निर्भर करता है।

उपयोग

 killtree.sh PID SIGNAL 

Killtrees.sh की सामग्री

 #!/bin/bash PID=$1 if [ -z $PID ]; then echo "No pid specified" fi PPLIST=$PID CHILD_LIST=`pgrep -P $PPLIST -d,` while [ ! -z "$CHILD_LIST" ] do PPLIST="$PPLIST,$CHILD_LIST" CHILD_LIST=`pgrep -P $CHILD_LIST -d,` done SIGNAL=$2 if [ -z $SIGNAL ] then SIGNAL="TERM" fi #do substring from comma to space kill -$SIGNAL ${PPLIST//,/ } 

यहां @ ज़िगांग के उत्तर की एक भिन्नता है जो एडब्ल्यूके के बिना करता है, केवल बाश की देशी पार्सिंग संभावनाओं पर निर्भर करता है:

 function killtree { kill -STOP "$1" ps -e -o pid= -o ppid= | while read -r pid ppid do [[ $ppid = $1 ]] || continue killtree "$pid" || true # Skip over failures done kill -CONT "$1" kill -TERM "$1" } 

ऐसा लगता है कि दोनों मैक और लिनक्स पर ठीक काम करते हैं। ऐसे परिस्थितियों में जहां आप प्रक्रिया समूहों का प्रबंधन करने में सक्षम नहीं हो सकते हैं – जैसे कि सॉफ़्टवेयर के एक टुकड़े के परीक्षण के लिए स्क्रिप्ट लिखते हैं, जिसे कई वातावरण में बनाया जाना चाहिए – यह पेड़-पैदल तकनीक निश्चित रूप से सहायक है

बच्चों से पहले माता-पिता को मारना बेहतर होगा; अन्यथा माता-पिता शायद खुद को मारने से पहले ही नए बच्चे पैदा कर सकते हैं ये हत्या से बचेंगे

Ps का मेरा संस्करण ऊपर से भिन्न है; शायद बहुत पुराना है, इसलिए अजीब तरह की प्रथा …

शेल फ़ंक्शन के बजाय शेल स्क्रिप्ट का उपयोग करने के लिए कई फायदे हैं …

हालांकि, यह मूल रूप से विचार zhigangs है


 #!/bin/bash if test $# -lt 1 ; then echo >&2 "usage: kiltree pid (sig)" fi ; _pid=$1 _sig=${2:-TERM} _children=$(ps j | grep "^[ ]*${_pid} " | cut -c 7-11) ; echo >&2 kill -${_sig} ${_pid} kill -${_sig} ${_pid} for _child in ${_children}; do killtree ${_child} ${_sig} done 

निम्नलिखित नि: शुल्क बीएसडीडी, लिनक्स और मैकोज़ एक्स पर परीक्षण किया गया है और यह केवल पीजीआरआर पर निर्भर करता है और मारता है (पीएस-ओ संस्करण बीएसडी के तहत काम नहीं करते हैं)। पहला तर्क माता पिता की पिड है जिसमें बच्चों को समाप्त करना है दूसरा तर्क यह निर्धारित करने के लिए एक बूलियन है कि क्या माता-पिता को भी समाप्त कर दिया गया है या नहीं।

 KillChilds() { local pid="${1}" local self="${2:-false}" if children="$(pgrep -P "$pid")"; then for child in $children; do KillChilds "$child" true done fi if [ "$self" == true ]; then kill -s SIGTERM "$pid" || (sleep 10 && kill -9 "$pid" &) fi } KillChilds $$ > /dev/null 2>&1 

यह किसी शैल स्क्रिप्ट के भीतर किसी भी बच्चे / पोते की प्रक्रिया को SIGTERM भेज देगा और यदि SIGTERM सफल नहीं होता है, यह 10 सेकंड प्रतीक्षा करेगा और फिर मार देगा।


पहले जवाब:

निम्नलिखित भी काम करता है, लेकिन बीएसडी पर शेल खुद को मार देगा।

 KillSubTree() { local parent="${1}" for child in $(ps -o pid=$parent); do if [ $$ -ne $child ]; then (kill -s SIGTERM $child || (sleep 10 && kill -9 $child & )) > /dev/null 2>&1 ; fi done } # Example lanch from within script KillSubTree $$ > /dev/null 2>&1 

मैं झीगांग, ज़्यूरि और सॉलिडेंक का समाधान विकसित कर रहा हूं:

  #!/bin/bash if test $# -lt 1 ; then echo >&2 "usage: kiltree pid (sig)" exit 1 ; fi ; _pid=$1 _sig=${2:-TERM} # echo >&2 "killtree($_pid) mypid = $$" # ps axwwf | grep -6 "^[ ]*$_pid " >&2 ; function _killtree () { local _children local _child local _success if test $1 -eq $2 ; then # this is killtree - don't commit suicide! echo >&2 "killtree can´t kill it´s own branch - some processes will survive." ; return 1 ; fi ; # this avoids that children are spawned or disappear. kill -SIGSTOP $2 ; _children=$(ps -o pid --no-headers --ppid $2) ; _success=0 for _child in ${_children}; do _killtree $1 ${_child} $3 ; _success=$(($_success+$?)) ; done ; if test $_success -eq 0 ; then kill -$3 $2 fi ; # when a stopped process is killed, it will linger in the system until it is continued kill -SIGCONT $2 test $_success -eq 0 ; return $? } _killtree $$ $_pid $_sig 

यह संस्करण अपने पूर्वजों को मारने से बच जाएगा – जो पिछले समाधानों में बाल प्रक्रियाओं की बाढ़ का कारण बनता है।

बच्चे की सूची निर्धारित होने से पहले प्रक्रियाएं ठीक से बंद कर दी जाती हैं, ताकि कोई नया बच्चा पैदा न हो जाए या गायब हो जाए।

मारे जाने के बाद, सिस्टम से रुक गई नौकरियों को गायब करना जारी रखा जाना चाहिए।

आपके ज्ञान के लिए धन्यवाद, लोग मेरी स्क्रिप्ट कुछ बाल प्रक्रियाओं को बाहर निकलने के लिए छोड़ रही थी और निषेध टिप ने चीजों को आसान बना दिया। यदि अन्यथा आवश्यक हो तो मैंने इस फ़ंक्शन को अन्य स्क्रिप्ट में लिखा है:

 # kill my group's subprocesses: killGroup # kill also myself: killGroup -x # kill another group's subprocesses: killGroup N # kill that group all: killGroup -x N # N: PID of the main process (= process group ID). function killGroup () { local prid mainpid case $1 in -x) [ -n "$2" ] && kill -9 -$2 || kill -9 -$$ ;; "") mainpid=$$ ;; *) mainpid=$1 ;; esac prid=$(ps ax -o pid,pgid | grep $mainpid) prid=${prid//$mainpid/} kill -9 $prid 2>/dev/null return } 

चीयर्स।

यदि आपके सिस्टम पर pstree और perl है, तो आप यह कोशिश कर सकते हैं:

 perl -e 'kill 9, (`pstree -p PID` =~ m/\((\d+)\)/sg)' 

यदि आप जिस चीज को मारना चाहते हैं उसका पिन पता है, आप आमतौर पर सत्र आईडी से, और एक ही सत्र में सब कुछ कर सकते हैं। मैं दो बार जांच करूँगा, लेकिन मैं इसे स्क्रिप्ट्स के लिए इस्तेमाल किया, जो कि loops में आरएसआईएनसीक्स शुरू करना चाहते हैं, जिसे मैं मरना चाहता हूं, और किसी अन्य (लूप की वजह से) प्रारंभ नहीं करना चाहिये क्योंकि यह होगा कि मैं सिर्फ rsync को मार दूंगा।

 kill $(ps -o pid= -s $(ps -o sess --no-heading --pid 21709)) 

यदि आप पीड को नहीं जानते हैं तो आप अभी भी अधिक घोंसला कर सकते हैं

 kill $(ps -o pid= -s $(ps -o sess --no-heading --pid $(pgrep rsync ))) 
 ps -o pid= --ppid $PPID | xargs kill -9 

शैल स्क्रिप्ट में बाल प्रक्रिया की हत्या:

कई बार हमें बाल प्रक्रिया को मारने की ज़रूरत है जो फांसी पर लगी है या किसी वजह से अवरुद्ध है। जैसे। एफ़टीपी कनेक्शन समस्या

दो दृष्टिकोण हैं,

1) प्रत्येक बच्चे के लिए अलग-अलग नए माता-पिता बनाने के लिए जो समय-समय पर पहुंचने के बाद बाल प्रक्रिया की निगरानी और मार डालेगा।

निम्नानुसार test.sh बनाएँ,

 #!/bin/bash declare -a CMDs=("AAA" "BBB" "CCC" "DDD") for CMD in ${CMDs[*]}; do (sleep 10 & PID=$!; echo "Started $CMD => $PID"; sleep 5; echo "Killing $CMD => $PID"; kill $PID; echo "$CMD Completed.") & done exit; 

और प्रक्रियाओं को देखें जो कि निम्नलिखित कमांड का प्रयोग करते हुए अन्य टर्मिनल में 'परीक्षण' नाम रखे हुए हैं।

 watch -n1 'ps x -o "%p %r %c" | grep "test" ' 

स्क्रिप्ट से ऊपर 4 नई बाल प्रक्रियाएं और उनके माता-पिता पैदा होंगे। प्रत्येक बच्चे की प्रक्रिया 10sec के लिए चलेगी लेकिन 5sec तक पहुंचने के बाद, उनके संबंधित माता-पिता की प्रक्रिया उन बच्चों को मार डालेगी। तो बच्चा निष्पादन (10sec) को पूरा करने में सक्षम नहीं होगा। एक और व्यवहार देखने के लिए उन समय (10 और 5 स्विच) के आसपास खेलते हैं। उस स्थिति में बच्चा 5sec में निष्पादन समाप्त करने से पहले 10sec का समय समाप्त हो जाएगा।

2) एक बार समय समाप्ति के बाद वर्तमान माता पिता की निगरानी करें और बाल प्रक्रिया को मार दें। यह प्रत्येक बच्चे की निगरानी करने के लिए अलग-अलग माता पिता नहीं बनाएगा इसके अलावा आप सभी मूल प्रक्रियाओं को उसी माता-पिता के भीतर ठीक से प्रबंधित कर सकते हैं।

निम्नानुसार test.sh बनाएँ,

 #!/bin/bash declare -A CPIDs; declare -a CMDs=("AAA" "BBB" "CCC" "DDD") CMD_TIME=15; for CMD in ${CMDs[*]}; do (echo "Started..$CMD"; sleep $CMD_TIME; echo "$CMD Done";) & CPIDs[$!]="$RN"; sleep 1; done GPID=$(ps -o pgid= $$); CNT_TIME_OUT=10; CNT=0; while (true); do declare -A TMP_CPIDs; for PID in "${!CPIDs[@]}"; do echo "Checking "${CPIDs[$PID]}"=>"$PID; if ps -p $PID > /dev/null ; then echo "-->"${CPIDs[$PID]}"=>"$PID" is running.."; TMP_CPIDs[$PID]=${CPIDs[$PID]}; else echo "-->"${CPIDs[$PID]}"=>"$PID" is completed."; fi done if [ ${#TMP_CPIDs[@]} == 0 ]; then echo "All commands completed."; break; else unset CPIDs; declare -A CPIDs; for PID in "${!TMP_CPIDs[@]}"; do CPIDs[$PID]=${TMP_CPIDs[$PID]}; done unset TMP_CPIDs; if [ $CNT -gt $CNT_TIME_OUT ]; then echo ${CPIDs[@]}"PIDs not reponding. Timeout reached $CNT sec. killing all childern with GPID $GPID.."; kill -- -$GPID; fi fi CNT=$((CNT+1)); echo "waiting since $b secs.."; sleep 1; done exit; 

और प्रक्रियाओं को देखें जो कि निम्नलिखित कमांड का प्रयोग करते हुए अन्य टर्मिनल में 'परीक्षण' नाम रखे हुए हैं।

 watch -n1 'ps x -o "%p %r %c" | grep "test" ' 

ऊपर की स्क्रिप्ट 4 नई बाल प्रक्रियाएं बनाएगी। हम सभी चाइल्ड प्रोसेस के पाइड को संचित कर रहे हैं और जांच करने के लिए उन पर पाशन कर रहे हैं कि क्या वे अपना निष्पादन समाप्त कर चुके हैं या अभी भी चल रहे हैं। CMD_TIME समय तक बाल प्रक्रिया का निष्पादन होगा। लेकिन यदि CNT_TIME_OUT समय-समय पर पहुंच जाए, तो सभी बच्चों को माता-पिता की प्रक्रिया से मार दिया जाएगा। आप व्यवहार को देखने के लिए समय बदल सकते हैं और स्क्रिप्ट के साथ चारों ओर खेल सकते हैं। इस दृष्टिकोण का एक दोष यह है कि यह सभी बच्चे के पेड़ को मारने के लिए समूह आईडी का उपयोग कर रहा है। लेकिन माता-पिता की प्रक्रिया ही एक ही समूह से संबंधित है, इसलिए इसे भी मार दिया जाएगा।

यदि आपको माता-पिता को मारना नहीं चाहिए, तो आपको मूल प्रक्रिया को अन्य समूह आईडी निर्दिष्ट करना पड़ सकता है

अधिक विवरण यहां मिल सकता है,

शैल स्क्रिप्ट में बाल प्रक्रिया को मारना

यह स्क्रिप्ट भी काम करती है:

#/bin/sh while true do echo "Enter parent process id [type quit for exit]" read ppid if [ $ppid -eq "quit" -o $ppid -eq "QUIT" ];then exit 0 fi for i in `ps -ef| awk '$3 == '$ppid' { print $2 }'` do echo killing $i kill $i done done

पुराने प्रश्न, मुझे पता है, लेकिन सभी प्रतिक्रियाएं पी.एस. फोन करने लगती हैं, जिसे मैं पसंद नहीं करता था

इस awk- आधारित समाधान के लिए recursion की आवश्यकता नहीं है और केवल एक बार ps को कॉल करता है

 awk 'BEGIN { p=1390 while ("ps -o ppid,pid"|getline) a[$1]=a[$1]" "$2 o=1 while (o==1) { o=0 split(p, q, " ") for (i in q) if (a[q[i]]!="") { p=p""a[q[i]] o=1 a[q[i]]="" } } system("kill -TERM "p) }' 

या एक एकल पंक्ति पर:

 awk 'BEGIN {p=1390;while ("ps -o ppid,pid"|getline) a[$1]=a[$1]" "$2;o=1;while (o==1) {o=0;split(p, q, " ");for (i in q) {if (a[q[i]]!="") {p=p""a[q[i]];o=1;a[q[i]]=""}}}system("kill -TERM "p)}' 

असल में यह विचार यह है कि हम माता-पिता की एक सरणी (ए) का निर्माण करते हैं: बाल प्रविष्टियां, फिर हमारे मेल खाने वाले माता-पिता के लिए बच्चों को ढूँढ़ने के आसपास के पाश, हमारे माता-पिता की सूची (पी) को जोड़ने के लिए जैसे ही हम जाते हैं।

यदि आप शीर्ष-स्तरीय प्रक्रिया को मारना नहीं चाहते हैं, तो कर रहे हैं

 sub(/[0-9]*/, "", p) 

सिस्टम () पंक्ति से पहले इसे मार सेट से हटा दिया जाएगा।

ध्यान रखें कि यहां एक दौड़ की स्थिति है, लेकिन ये सभी समाधानों का (जहां तक ​​मैं देख सकता हूं) सच है। यह मेरे लिए क्या आवश्यक है क्योंकि जिस लिपि की मुझे इसकी ज़रूरत थी, वह बहुत ही अल्पकालिक बच्चों को पैदा नहीं करता है।

पाठक के लिए एक अभ्यास इसे 2-पास लूप बनाने के लिए होगा: पहले पास के बाद, पी सूची में सभी प्रक्रियाओं के लिए SIGSTOP भेजें, फिर पीओ को फिर से चलाने के लिए लूप करें और दूसरा पास SIGTERM भेजें, फिर SIGCONT अगर आप अच्छे अंत के बारे में परवाह नहीं करते हैं, तो दूसरा पास सिर्फ सिगिल हो सकता है, मुझे लगता है।

मुझे पता है कि यह पुराना है, लेकिन यही बेहतर उपाय है जो मैंने पाया:

 killtree() { for p in $(pstree -p $1 | grep -o "([[:digit:]]*)" |grep -o "[[:digit:]]*" | tac);do echo Terminating: $p kill $p done } 

Sh में नौकरियां कमांड पृष्ठभूमि प्रक्रियाओं की सूची देगा। कुछ मामलों में यह सबसे पहले नई प्रक्रिया को मारना बेहतर हो सकता है, उदाहरण के लिए पुराने एक ने साझा सॉकेट बनाया। उन मामलों में रिवर्स ऑर्डर में पीआईडी ​​को क्रमबद्ध करें। कभी-कभी आप डिस्क की चीज़ या चीजों पर कुछ लिखने के लिए नौकरियों के पल का इंतजार करना चाहते हैं, जैसे कि वे बंद होने से पहले।

और अगर आप की जरूरत नहीं है मार नहीं!

 for SIGNAL in TERM KILL; do for CHILD in $(jobs -s|sort -r); do kill -s $SIGNAL $CHILD sleep $MOMENT done done