बैश और रेगेक्स का उपयोग करके एक लाइन में एक प्रक्रिया को ढूंढें और मारें

Question

मुझे अक्सर प्रोग्रामिंग के दौरान एक प्रक्रिया को मारने की आवश्यकता होती है।

जिस तरह से मैं अब यह है:

[~]$ ps aux | grep 'python csp_build.py'
user    5124  1.0  0.3 214588 13852 pts/4    Sl+  11:19   0:00 python csp_build.py
user    5373  0.0  0.0   8096   960 pts/6    S+   11:20   0:00 grep python csp_build.py
[~]$ kill 5124

मैं प्रक्रिया आईडी को स्वचालित रूप से कैसे निकाल सकता हूं और इसे उसी पंक्ति में मार सकता हूं?

ऐशे ही:

[~]$ ps aux | grep 'python csp_build.py' | kill <regex that returns the pid>

Comments

मुझ पर विश्वास करो! : 'आपके द्वारा चुना गया पहला उत्तर आपके उत्तर में आपके द्वारा बताए गए समाधान की तुलना में अधिक जटिल है। मैं बल्कि आपका रास्ता चुनूंगा।

— संतोष कुमार

अगर प्रक्रिया मौजूद है तो जांच करने का सबसे अच्छा तरीका: stackoverflow.com/questions/3043978/…

— ट्रेवर बॉयड स्मिथ

Answer 1

में bash, आपको करने में सक्षम होना चाहिए:

kill $(ps aux | grep '[p]ython csp_build.py' | awk '{print $2}')

इसके कामकाज का विवरण इस प्रकार है:

• psआप सभी प्रक्रियाओं की सूची देता है।
• grepफिल्टर है कि आपकी खोज स्ट्रिंग के आधार पर, [p]एक चाल है आप वास्तविक उठा रोकने के लिए grepप्रक्रिया ही।
• awkकेवल आपके प्रत्येक पंक्ति, जो पीआईडी है के दूसरे क्षेत्र देता है।
• $(x)निर्माण साधन निष्पादित करने के लिए xतो इसके उत्पादन लेने के लिए और यह कमांड लाइन पर डाल दिया। psउपरोक्त निर्माण के अंदर उस पाइपलाइन का आउटपुट प्रक्रिया आईडी की सूची है ताकि आप एक कमांड के साथ समाप्त हो जाएं जैसे kill 1234 1122 7654।

यहां एक प्रतिलेख दिखाया गया है जो इसे कार्रवाई में दिखाता है:

pax> sleep 3600 &
[1] 2225
pax> sleep 3600 &
[2] 2226
pax> sleep 3600 &
[3] 2227
pax> sleep 3600 &
[4] 2228
pax> sleep 3600 &
[5] 2229
pax> kill $(ps aux | grep '[s]leep' | awk '{print $2}')
[5]+  Terminated              sleep 3600
[1]   Terminated              sleep 3600
[2]   Terminated              sleep 3600
[3]-  Terminated              sleep 3600
[4]+  Terminated              sleep 3600

और आप इसे सभी स्लीपर्स को समाप्त करते हुए देख सकते हैं।

---

grep '[p]ython csp_build.py'बिट को थोड़ा और विस्तार से समझाते हुए :

जब आप इसका sleep 3600 &अनुसरण ps -ef | grep sleepकरते हैं, तो आप इसके साथ दो प्रक्रियाएँ प्राप्त करते हैं sleep, sleep 3600और grep sleep( और क्योंकि इन दोनों sleepमें है, यह रॉकेट विज्ञान नहीं है)।

हालांकि, ps -ef | grep '[s]leep'इसके साथ एक प्रक्रिया नहीं बनाई जाएगी sleep, यह इसके बजाय बनाता है grep '[s]leep'और यहाँ मुश्किल सा है: grepइसे नहीं ढूंढता क्योंकि यह नियमित अभिव्यक्ति की तलाश में है "चरित्र वर्ग के किसी भी चरित्र [s](जो है s) द्वारा पीछा किया जाता है leep।

दूसरे शब्दों में, यह खोज है sleepलेकिन grep प्रक्रिया है grep '[s]leep'जो इसमें नहीं है sleep।

जब मुझे यह दिखाया गया (एसओ पर यहां किसी के द्वारा), तो मैंने तुरंत इसका इस्तेमाल करना शुरू कर दिया

• यह जोड़ने की तुलना में एक कम प्रक्रिया है | grep -v grep; तथा
• यह सुरुचिपूर्ण और डरपोक है, एक दुर्लभ संयोजन :-)

Comments

@ paxdiablo, क्या आप उसके लिए लिंक प्रदान कर सकते हैं? मैं चकित हूं कि यह क्यों काम करता है।

— ग्लेन जैकमैन

आप केवल awk - ps aux का उपयोग कर सकते हैं | awk '/ [b] eam / {प्रिंट $ 2}' , कोई grep की जरूरत नहीं

— Yola

केवल pgrep या pkill का उपयोग करने के लिए बेहतर है

— NGix

एक छोटा सा मुद्दा है - अगर प्रक्रिया पहले ही समाप्त हो गई है, killतो मानक उत्पादन के साथ विल की यह रेखा मंथन करेगीkill: usage: kill [-s sigspec | -n signum | -sigspec] pid | jobspec ... or kill -l [sigspec]

— लियोनेल चान

इसके बजाय grep '[p]ython csp_build.py'आप भी उपयोग कर सकते हैं kill $(ps aux | grep 'python csp_build.py' | grep -v grep | awk '{print $2}'):। grep -vबिना मिलान वाली रेखाएँ देता है।

— usandfriends 4

Answer 2

अगर आपके पास pkill है,

pkill -f csp_build.py

यदि आप केवल प्रक्रिया के नाम (पूर्ण तर्क सूची के बजाय) के खिलाफ टटोलना चाहते हैं तो छोड़ दें -f।

Comments

जब मैंने यह परीक्षण किया तो कुछ नहीं हुआ।

— ऑर्जनप

सत्यापित करने के लिए पहले pgrep का उपयोग करें कि आपने सही प्रक्रिया को पकड़ लिया है। फिर सही पैटर्न पर फिर से pkill का उपयोग करें।

— भूतडॉग ghost४

+1। pgrepऔर pkillजब तक आप प्रक्रिया को सही ढंग से निर्दिष्ट करने के लिए ध्यान रखते हैं तब तक काम करते हैं। डिफ़ॉल्ट रूप से केवल प्रक्रिया नाम का मिलान किया जाता है, जो इस मामले में लगभग निश्चित रूप से सिर्फ "अजगर" है। pgrep -f "python csp_build.py"पूर्ण कमांड से मिलान करने के लिए उपयोग करें ।

— mr.spuratic

आपको किल के साथ जबरदस्ती करने की आवश्यकता हो सकती हैpkill -9 -f csp_build.py

— स्टडजेक

यह सच में स्वीकार किए जाते हैं और शीर्ष मतदान का जवाब होना चाहिए; ये सभी जागृति के साथ अन्य थोड़े अनावश्यक हैं। मुझे उम्मीद है कि इस पृष्ठ को खोजने वाले लोग उस पहले उत्तर से आगे पढ़ेंगे।

— जेसन सी

Answer 3

एक लाइन:

ps aux | grep -i csp_build | awk '{print $2}' | xargs sudo kill -9

• कॉलम 2 का प्रिंट आउट लें: awk '{print $2}'
• sudo वैकल्पिक है
• भागो kill -9 5124, kill -9 5373आदि (मार -15 अधिक सुंदर है, लेकिन थोड़ा धीमा है)

---

बक्शीश:

मेरे पास भी 2 शॉर्टकट फ़ंक्शंस हैं जो मेरे .bash_profile (~ / .bash_profile में परिभाषित हैं) ओएक्सएक्स के लिए हैं, आपको यह देखना होगा कि आपके * निक्स मशीन के लिए क्या काम करता है)।

1. p कीवर्ड
   • कीवर्ड वाले सभी P rocesses को सूचीबद्ध करता है
   • उपयोग जैसे: p csp_build, p pythonआदि

bash_profile कोड:

# FIND PROCESS
function p(){
        ps aux | grep -i $1 | grep -v grep
}

2. ka कीवर्ड
   • कश्मीर से संबंधित बीमारियों का एक डालूँगा प्रक्रियाओं इस कीवर्ड है
   • उपयोग जैसे: ka csp_build, ka pythonआदि
   • वैकल्पिक मार स्तर जैसे: ka csp_build 15,ka python 9

bash_profile कोड:

# KILL ALL
function ka(){

    cnt=$( p $1 | wc -l)  # total count of processes found
    klevel=${2:-15}       # kill level, defaults to 15 if argument 2 is empty

    echo -e "\nSearching for '$1' -- Found" $cnt "Running Processes .. "
    p $1

    echo -e '\nTerminating' $cnt 'processes .. '

    ps aux  |  grep -i $1 |  grep -v grep   | awk '{print $2}' | xargs sudo kill -klevel
    echo -e "Done!\n"

    echo "Running search again:"
    p "$1"
    echo -e "\n"
}

Comments

अनुस्मारक - नए कार्यों को लोड करने के लिए बैश शेल (टर्मिनल) को पुनरारंभ करना न भूलें। या source ~/.bash_profileनए कार्यों को आयात करने के लिए वर्तमान शेल में चलाएं (यह वही है जो मुझे पसंद है)।

— a20

यहाँ कई अन्य उत्तरों की तरह, यह स्मरणीय रूप से बेकार उपयोगgrep से ग्रस्त है । याद रखें, जो कुछ भी दिखता है grep x | awk '{ y }'वह आम तौर पर बेहतर और अक्सर अधिक मजबूत होता है यदि आप इसे प्रतिस्थापित करते हैंawk '/x/ { y }'

— ट्रिप्लिक

@ जिस वेबसाइट को आप लिंक कर रहे हैं, उसे आप के अधिकार से जोड़ना है? मुझे लगता है कि आप इसे विभिन्न टिप्पणियों अनुभागों से जोड़ रहे हैं। क्या आप SEO बनाने की कोशिश कर रहे हैं?

— a20

नहीं, मुझे SEO में कोई दिलचस्पी नहीं है। मैं जागरूकता पैदा करने की उम्मीद कर रहा हूं।

— त्रिकाल

.. अपनी वेबसाइट से लिंक करके के रूप में अगर यह एक स्थापित प्राधिकारी साइट है। अच्छा लगा। इसके अलावा, grep तेज है ।

— a20

Answer 4

killall -r regexp

-r, --regexp

विस्तारित नियमित अभिव्यक्ति के रूप में प्रक्रिया नाम पैटर्न की व्याख्या करें।

Answer 5

प्रयोग करके देखें

ps aux | grep 'python csp_build.py' | head -1 | cut -d " " -f 2 | xargs kill

Comments

इसे थोड़ा बदलना पड़ा। यह काम किया। धन्यवाद। :) ps aux | grep 'अजगर csp_build.py' | सिर -1 | कट -d "" -f 5 | xargs मार

— Orjanp

ps aux | grep 'python csp_build.py' | awk '{print $2}' | xargs killमेरे लिए काम किया। thanx

— रसिका परेरा

याद रखें, बच्चों, Awk सब कुछ grepकर सकते हैं, और यह ज्यादातर बस और सुरुचिपूर्ण ढंग से। का तुच्छ मामला grep x y | awk '{ z }'हमेशा बेहतर लिखा जाता है awk '/x/ { z }' y- इसकाgrep भी बेकार उपयोग देखें ।

— त्रिपाली

Answer 6

आप केवल उपयोग कर सकते हैं pkill '^python*' रेगेक्स प्रक्रिया हत्या के लिए ।

यदि आप यह देखना चाहते हैं कि आपको मारने से पहले क्या मिलेगा या मारना होगा तो उपयोग करें pgrep -l '^python*'जहां -l आउटपुट प्रक्रिया का नाम भी है। यदि आप उपयोग नहीं करना चाहते हैं pkill, तो बस उपयोग करें:

pgrep '^python*' | xargs kill

Answer 7

Pgrep का उपयोग करें - कई प्लेटफार्मों पर उपलब्ध:

kill -9 `pgrep -f cps_build`

pgrep -f संयोग से सभी पीआईडी ​​लौटाएगा "cps_build"

Comments

अगर आपके पास है pgrep, तो आपके पास भी होगा pkill। हमेशा की तरह, तब तक उपयोग न करेंkill -9 जब तक आप यह नहीं जानते कि kill -15(डिफ़ॉल्ट) क्यों या kill -2काम नहीं करेगा।

— ट्रिपल

यह @ nathanel के उत्तर की तुलना में एक खराब विरोधाभास जैसा दिखता है जो गलत तरीके से छूट जाता है -9और उचित आधुनिक कमांड प्रतिस्थापन सिंटैक्स का उपयोग करता है। इसके बजाय अपवोट करें; हालांकि, pkillजवाब अभी भी बेहतर है।

— ट्रिपल जूल

@tripleee इस मामले में किल -9 ठीक वही है जो मैं चाहता हूं - सभी अपराधियों को अत्यधिक पूर्वाग्रह के साथ समाप्त करें। इसके अलावा, मैंने कई सालों तक किल -9 का इस्तेमाल किया है जिसमें कोई समस्या नहीं है। मेरी राय में, हमेशा शुद्धतावादियों का एक शिविर होगा - गेट-ऑफ़-थिंग्स रियलिस्ट्स का एक शिविर, और मैं बाद वाले (इस मामले में) से संबंधित हूं।

— a20

क्या आपको "जब तक आपको पता नहीं है" भाग क्यों याद आया? मैं सभी चीजों को पूरा करने के लिए हूं, लेकिन यह पैर में अपने आप को गोली मारने के सामान्य तरीकों में से एक है जब तक आप यह नहीं समझते कि -9वास्तव में इसका क्या मतलब है।

— ट्रिपल जी

@tripleee हे ट्रिपली, मैंने हाल ही में पाया कि आप सही हैं, किल -15 एक बेहतर विकल्प है क्योंकि यह ऐप को ख़ुशी से मारने का मौका देता है। मैंने अपना कोड तदनुसार बदल दिया है: stackoverflow.com/a/30486159/163382

— a20

Answer 8

यह केवल पीआईडी ​​लौटाएगा

pgrep -f 'process_name'

तो किसी भी प्रक्रिया को एक पंक्ति में मारने के लिए:

kill -9 $(pgrep -f 'process_name')

या, यदि आप प्रक्रिया का सही नाम जानते हैं, तो आप पिडोफ़ भी आज़मा सकते हैं:

kill -9 $(pidof 'process_name')

लेकिन, यदि आप प्रक्रिया का सही नाम नहीं जानते हैं, pgrepतो बेहतर होगा।

यदि एक ही नाम के साथ कई प्रक्रिया चल रही है, और आप पहले एक को मारना चाहते हैं:

kill -9 $(pgrep -f 'process_name' | head -1)

यह भी ध्यान दें कि, यदि आप केस सेंसिटिविटी से चिंतित हैं तो आप grep की तरह -i विकल्प जोड़ सकते हैं। उदाहरण के लिए:

kill -9 $(pgrep -fi chrome)

पर संकेतों और pgrep बारे में अधिक जानकारी man 7 signalया man signalऔरman pgrep

Answer 9

आप इसे awk और backtics के साथ कर सकते हैं

ps auxf |grep 'python csp_build.py'|`awk '{ print "kill " $2 }'`

$ 2 अवेक प्रिंट 2 कॉलम में, और बैकटिक्स उस स्टेटमेंट को चलाता है जो प्रिंट किया गया है।

लेकिन अजगर प्रक्रिया के लिए एक बहुत क्लीनर समाधान होगा यह स्टोर करने के लिए प्रक्रिया आईडी / var / रन में है और फिर आप बस उस फ़ाइल को पढ़ सकते हैं और इसे मार सकते हैं।

Comments

क्या आप 5124 और 5373 दोनों प्रक्रिया को नहीं मारेंगे? मुझे लगता है कि यह कोई समस्या नहीं है।

— ऑर्जनप

यह एक समस्या नहीं होनी चाहिए, लेकिन आप हमेशा grep प्रक्रिया को बाहर करने के लिए एक और grep जोड़ सकते हैं: grep और awk के बीच "grep -v grep"

— अलेक्जेंडर Kjäll

थोड़ा संशोधित आदेश के साथ परीक्षण किया गया। लेकिन इसने इस प्रक्रिया को नहीं मारा, केवल प्रिंट <pid> मारा। ps auxf | grep '[p] ython csp_build.py' | awk '{print "मार" $ 2} "

— Orjanp

केवल एक सिस्टम ("मार" $ 2) के साथ प्रिंट "किल" $ 2 स्टेटमेंट को स्वैप करने की आवश्यकता है। तब यह काम करता है। :)

— Orjanp

Answer 10

मेरा काम regexp से मेल खाने वाली हर चीज को मार रहा था, जिसे विशिष्ट निर्देशिका में रखा गया था (सेलेनियम परीक्षणों के बाद सब कुछ बंद नहीं हुआ)। यह मेरे लिए काम किया:

for i in `ps aux | egrep "firefox|chrome|selenium|opera"|grep "/home/dir1/dir2"|awk '{print $2}'|uniq`; do kill $i; done

Comments

का -9विकल्प killशायद बहुत आक्रामक है। यह उन्हें अपने संसाधनों को मुक्त करने की अनुमति नहीं देता है।

— बिरयानी B

अच्छा! केवल एक ही इस तथ्य पर विचार करता है कि एक से अधिक मिलान प्रक्रिया हो सकती है! एक छोटा नोट: शायद आप पाइप में "grep -v grep" या ऐसा कुछ जोड़ना चाहते हैं, जिससे यह सुनिश्चित हो सके कि grep प्रक्रिया ही आपकी प्रक्रिया सूची में दिखाई न दे।

— ब्रैड पार्क

killकई प्रक्रियाओं को स्वीकार करता है इसलिए लूप मूल रूप से बेकार है; और जैसा कि इस पृष्ठ पर कहीं और उल्लेख किया गया है, आपको kill -9तब तक उपयोग नहीं करना चाहिए जब तक आप यह नहीं जानते कि यह प्रक्रिया सिर्फ जवाब नहीं देगी kill।

— ट्रिपलए

हटाने -9 एक बड़ी बात नहीं है, क्यों नीचे की ओर। आपने उत्तर को बेहतर तरीके से संपादित किया होगा।

— सर्ज

Answer 11

midoriउदाहरण के लिए, कीवर्ड द्वारा प्रक्रिया को मारने के लिए:

kill -SIGTERM $(pgrep -i midori)

Answer 12

केवल awk(और ps) का उपयोग करने वाला एक तरीका :

ps aux | awk '$11" "$12 == "python csp_build.py" { system("kill " $2) }'

स्ट्रिंग समानता परीक्षण का उपयोग करके मैं इस प्रक्रिया से मेल खाने से रोकता हूं।

Comments

किसी कारण से मुझे "python csp_build.py" पर हिट नहीं मिलती है। लेकिन "अजगर" अकेला हिट है।

— ऑर्जनप

Answer 13

ps -o uid,pid,cmd|awk '{if($1=="username" && $3=="your command") print $2}'|xargs kill -15

Comments

दैनिक सीमा के कारण +1 नहीं किया जा सकता, लेकिन विकल्प के psसाथ उपयोग -oकरने लायक है।

— पी शेव

पीएस मुझे ज्यादा मत देना। [~] $ ps PID TTY TIME CMD 6365 pts / 6 00:00:00 ps 29112 pts / 6 00:00:00 bash

— Orjanp

Answer 14

दे खना-to pkill

pkill -f /usr/local/bin/fritzcap.py

.py फ़ाइल का सटीक पथ है

# ps ax | grep fritzcap.py
 3076 pts/1    Sl     0:00 python -u /usr/local/bin/fritzcap.py -c -d -m

Answer 15

मैंने कुछ इस तरह से उपयोग करना शुरू किया:

kill $(pgrep 'python csp_build.py')

Answer 16

एक आम पीपीआईडी से शुरू की गई हमारी अपनी प्रक्रियाओं को मारना काफी अक्सर है, झंडे से जुड़ा पुकिल–P मेरे लिए एक विजेता है। @ Ghostdog74 उदाहरण का उपयोग करना:

# sleep 30 &                                                                                                      
[1] 68849
# sleep 30 &
[2] 68879
# sleep 30 &
[3] 68897
# sleep 30 &
[4] 68900
# pkill -P $$                                                                                                         
[1]   Terminated              sleep 30
[2]   Terminated              sleep 30
[3]-  Terminated              sleep 30
[4]+  Terminated              sleep 30

Answer 17

आपको ps के लिए उपयोगकर्ता स्विच की आवश्यकता नहीं है।

kill `ps ax | grep 'python csp_build.py' | awk '{print $1}'`

Answer 18

कुछ मामलों में, मैं इस तरह से प्रक्रिया को मारना चाहूंगा:

➜ ~ नींद 1000 और
[१] २५४१०
➜ ~ नींद 1000 और
[२] २५४१५
➜ ~ नींद 1000 और
[३] २५४२१
➜ ~ पिडोफ नींद
25421 25415 25410
➜ ~ मार डालो `पिडोफ स्लीप`
[२] - २५४१५ समाप्त नींद १०००                                                             
[१] - २५४१० की नींद १००० समाप्त हुई
[३] + २५४२१ में नींद १००० समाप्त हुई

लेकिन, मुझे लगता है कि यह आपके मामले में थोड़ा अनुचित है। (हो सकता है कि पृष्ठभूमि में अजगर ए, अजगर बी, अजगर एक्स ... चल रहे हों।)

Answer 19

यदि pkill -f csp_build.pyआप उस प्रक्रिया को नहीं मारते हैं जो आप -9एक किल सिग्नल भेजने के लिए जोड़ सकते हैं जिसे अनदेखा नहीं किया जाएगा। अर्थातpkill -9 -f csp_build.py

Answer 20

समाधान सटीक पैटर्न के साथ प्रक्रियाओं को फ़िल्टर करेगा, पिड को पार्स करेगा, और मार प्रक्रियाओं को निष्पादित करने के लिए एक तर्क सूची का निर्माण करेगा:

ps -ef  | grep -e <serviceNameA> -e <serviceNameB> -e <serviceNameC> |
awk '{print $2}' | xargs sudo kill -9

डोक्यूमनेशन से स्पष्टीकरण :

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

-उन सहित अन्य उपयोगकर्ताओं की प्रक्रियाओं के बारे में जानकारी प्रदर्शित करें

-यदि यूआईडी, पीआईडी, पैरेंट पिड, हाल ही में सीपीयू उपयोग, प्रक्रिया प्रारंभ प्रदर्शित करें

ग्रेप उपयोगिता खोजें किसी भी इनपुट फ़ाइलों को देखते हुए का चयन लाइनों कि

-e पैटर्न, --regexp = pattern इनपुट की खोज के दौरान उपयोग किए जाने वाले पैटर्न को निर्दिष्ट करें: यदि किसी निर्दिष्ट पैटर्न से मेल खाता है तो एक इनपुट लाइन का चयन किया जाता है। यह विकल्प सबसे उपयोगी है जब कई-विकल्पों का उपयोग कई पैटर्न को निर्दिष्ट करने के लिए किया जाता है, या जब एक पैटर्न डैश (`- ') से शुरू होता है।

xargs - तर्क सूची (ओं) का निर्माण और उपयोगिता का निष्पादन

मारना - किसी प्रक्रिया को समाप्त करना या संकेत देना

नंबर 9 का संकेत - किल (गैर-बिल्ली के समान, गैर-प्रज्वलित मार)

उदाहरण :

ps -ef  | grep -e node -e loggerUploadService.sh - -e applicationService.js |
awk '{print $2}' | xargs sudo kill -9

Answer 21

मैं इसका उपयोग फ़ायरफ़ॉक्स को मारने के लिए करता हूँ जब यह पटक पटक दिया जाता है और सीपीयू को कोसता है :) जिस ऐप को आप मरना चाहते हैं, उसके साथ 'फ़ायरफ़ॉक्स' को बदलें। मैं बैश शेल पर हूं - OS X 10.9.3 डार्विन।

kill -Hup $(ps ux | grep Firefox | awk 'NR == 1 {next} {print $2}' | uniq | sort)

Comments

के grep Firefox | awk 'NR == 1 { next } ...'साथ प्रतिस्थापित करने से awk 'NR == 1 || $11 !~ /Firefox/ { next } ...'न केवल एक प्रक्रिया बचती है, बल्कि सटीकता में भी सुधार होता है। sort | uniqशुद्ध अक् या में से छुटकारा पाना कठिन नहीं है (निश्चित रूप uniq | sortसे सिर्फ गलत है - यह किसी भी डुप्लिकेट को याद करेगा, जो आसन्न नहीं हैं, और अनावश्यक रूप से आउटपुट को सॉर्ट करके त्रुटि को छिपाते हैं uniq)।

— ट्रिपल एफ

Answer 22

मैं उपयोग करता हूं gkill processname, जहां gkill निम्नलिखित स्क्रिप्ट है:

cnt=`ps aux|grep $1| grep -v "grep" -c`
if [ "$cnt" -gt 0 ]
then
    echo "Found $cnt processes - killing them"
    ps aux|grep $1| grep -v "grep"| awk '{print $2}'| xargs kill
else
    echo "No processes found"
fi

नोट: यह उन प्रक्रियाओं को नहीं मारेगा जिनकी कमांड लाइन में "grep" है।

Comments

कई की तरह, याक शेड के कई अन्य सुदृढीकरण, यह और अन्य सामान्य शेल स्क्रिप्ट एंटीपैटर्न के बेकार उपयोग सेgrep भरा हुआ है ।

— ट्रिपल जूल

Answer 23

निम्नलिखित कमांड काम आएगी:

kill $(ps -elf | grep <process_regex>| awk {'print $4'})

जैसे।, ps -elf | grep top

    0 T ubuntu    6558  6535  0  80   0 -  4001 signal 11:32 pts/1    00:00:00 top
    0 S ubuntu    6562  6535  0  80   0 -  2939 pipe_w 11:33 pts/1    00:00:00 grep --color=auto top

kill -$(ps -elf | grep top| awk {'print $4'})

    -bash: kill: (6572) - No such process
    [1]+  Killed                  top

यदि प्रक्रिया अभी भी अटकी हुई है, तो हार्डकिल के लिए "-9" एक्सटेंशन का उपयोग करें, इस प्रकार है:

kill -9 $(ps -elf | grep top| awk {'print $4'})

उम्मीद है की वो मदद करदे...!

Answer 24

बैश में एक पंक्ति में सभी प्रक्रियाओं को ढूंढें और मारें।

kill -9 $(ps -ef | grep '<exe_name>' | grep -v 'grep' | awk {'print $2'})

• ps -ef | grep '<exe_name>'- चल रहे प्रक्रिया विवरण (नाम, पीआईडी, आदि) की सूची देता है जो पैटर्न से मेल खाता है। आउटपुट सूची में यह grepकमांड भी शामिल है जो इसे खोजती है। अब मारने के लिए हमें इस grepकमांड प्रक्रिया को अनदेखा करना होगा ।
• ps -ef | grep '<exec_name>' | grep -v 'grep'- -v 'grep'वर्तमान grep प्रक्रिया को हटाने के साथ एक और grep जोड़ना ।
• फिर प्रयोग करके awkप्रक्रिया आईडी को अकेले प्राप्त करें।
• फिर इस कमांड को अंदर रखें $(...)और कमांड को पास करें kill, सभी प्रक्रिया को मारने के लिए।

Answer 25

आप कमांड के pid को सूचीबद्ध करने के लिए कमांड के नीचे उपयोग कर सकते हैं। लिनक्स में सभी प्रक्रिया को देखने के लिए शीर्ष या बेहतर उपयोग htop का उपयोग करें। यहां मैं नाम की एक प्रक्रिया को मारना चाहता हूं

ps -ef | grep '/usr/lib/something somelocation/some_process.js'  | grep -v grep | awk '{print $2}'

और pid को वेरीफाई करे। यह उचित होना चाहिए। उन्हें मारने के आदेश का उपयोग करें।

sudo kill -9 `ps -ef | grep '/usr/lib/something somelocation/some_process.js'  | grep -v grep | awk '{print $2}'`

जैसे: - htop प्रक्रिया सूची से है।

sudo kill -9 `ps -ef | grep '<process>'  | grep -v grep | awk '{print $2}'`

यह मेरे मुद्दों को हल करता है। यदि आप गलती से किसी प्रक्रिया को मार देते हैं, तो प्रक्रिया को पुनः आरंभ करने के लिए हमेशा तैयार रहें।