మల్టీ-థ్రెడ్ బాష్ కోడ్‌ను అభివృద్ధి చేసేటప్పుడు, సర్వర్ ప్రాసెస్‌లను నిర్వహించేటప్పుడు లేదా ప్రాసెస్ వాచ్‌డాగ్‌లను సృష్టించేటప్పుడు, ప్రధాన సవాళ్లలో ఒకటి సాధారణంగా ఉన్న బాష్ ప్రాసెస్‌లను సరిగ్గా, సమర్థవంతంగా మరియు ఖచ్చితంగా ముగించడం. ఈ వ్యాసం మీకు ఎలా చూపుతుంది.

అంటే ఏమిటి బాష్ ప్రక్రియ?

బాష్ ప్రాసెస్ కేవలం రన్నింగ్ ఎక్జిక్యూటబుల్. ఉదాహరణకు, మీరు మీ డెస్క్‌టాప్ వాతావరణంలో కాలిక్యులేటర్‌ను ప్రారంభించినప్పుడు, బాష్ ప్రాసెస్ సృష్టించబడుతుంది. ఈ బాష్ రెండు ప్రధాన ప్రాసెస్ ఐడెంటిఫైయర్‌లను కలిగి ఉంది, అవి ఫైల్ PID ఇంకా పిపిఐడి, ది ప్రాసెస్ ఐడెంటిఫైయర్, ఇంకా మాతృ ప్రక్రియ ఐడెంటిఫైయర్.

సారాంశంలో, ది PID ఇచ్చిన రన్నింగ్ అప్లికేషన్ కోసం సంఖ్య ఆధారంగా ఒక ప్రత్యేకమైన ID ని కలిగి ఉంటుంది (అనగా ఒక ప్రక్రియ), అయితే పిపిఐడి ఏదైనా నడుస్తున్న అనువర్తనం కోసం (అనగా ప్రాసెస్) ఫైల్‌ను నిల్వ చేస్తుంది తల్లిదండ్రుల PID ఈ క్రొత్త అనువర్తనాన్ని ప్రారంభించిన ప్రక్రియ, అందువల్ల “పేరెంట్” అనే పదం.

ఇది చెట్టు నిర్మాణాన్ని ఎలా ఏర్పరుస్తుందో మీరు వెంటనే చూడవచ్చు, అన్ని ప్రక్రియలను రూట్ / మొదటి ప్రక్రియ వరకు అనుసంధానిస్తుంది పిపిఐడి యొక్క 0.

Linux లో రూట్ ప్రాసెస్

అదనపు అంతర్దృష్టులను మరియు సంబంధిత ఆచరణాత్మక ఉదాహరణను అందించే సంబంధిత వ్యాసం కోసం PID ఉంది పిపిఐడి, మీరు మా ఎగుమతి వేరియబుల్స్‌ను బాష్‌కు సమీక్షించాలనుకోవచ్చు: ఎందుకు మరియు ఎలా వ్యాసం.

బాష్ ప్రాసెస్‌ను నిర్వహించడం మొదటి చూపులో తేలికగా కనిపిస్తుంది (ఇప్పుడే రన్ చేయండి ps -ef మీ సిస్టమ్‌లో నడుస్తున్న అన్ని ప్రక్రియలను చూడటానికి మీ టెర్మినల్ యొక్క కమాండ్ లైన్‌లో PID ఉంది పిపిఐడి ఐడెంటిఫైయర్లు.

ఒక ప్రక్రియను ముగించడం కూడా సులభం అనిపిస్తుంది, కాని త్వరలో సంక్లిష్ట ప్రక్రియ నిర్వహణ వ్యవస్థలను నిర్వహించేటప్పుడు హెచ్చరికలు మరియు ఉపాయాలు తమను తాము అనుభూతి చెందడం ప్రారంభిస్తాయి.

బాష్ ప్రక్రియను చంపండి

ఫైల్‌ను అమలు చేయడం ద్వారా ప్రారంభిద్దాం gnome-calculator కమాండ్ లైన్లో ఆపై ప్రక్రియను ముగించండి.

gnome-calculator &
ps -ef | grep gnome-calculator
kill -9 $RELEVANT_PID

Linux లో ఒక సాధారణ చంపే ప్రక్రియ

మేము ప్రారంభించాము gnome-calculator నేపథ్య మోడ్‌లో (ఉపయోగించి & కమాండ్ చివరిలో), కాబట్టి మీరు మరొక టెర్మినల్ సెషన్‌ను ప్రారంభించకుండానే వెంటనే టెర్మినల్ ప్రాంప్ట్‌కు తిరిగి రావచ్చు.

తరువాత, మేము ఉపయోగించాము ps -ef ఒక గొట్టంతో కలిపి (|) ఇంకా grep ప్రాసెస్ ID ని కనుగొనడానికి ఆదేశం (PID) మా కాలిక్యులేటర్. తరువాత, మేము దానిని 9 సిగ్నల్‌తో ముగించాము kill ఆదేశం. భర్తీ చేయండి $RELEVANT_PID నివేదించిన PID తో కోడ్‌లో ps మీరు ఈ కోడ్‌ను ప్రయత్నిస్తే.

నేపథ్య ప్రక్రియ వెంటనే ఆపివేయబడుతుంది kill -9 సూచన. ఏదేమైనా, బాష్ కమాండ్ ప్రాంప్ట్ చాలా త్వరగా తిరిగి వస్తుంది, ఇది ప్రాసెస్ షెడ్యూలర్ బ్యాక్ గ్రౌండ్ ప్రాసెస్ ముగిసినట్లు నివేదించడానికి ముందే తిరిగి వస్తుంది.

నోటిఫికేషన్ ఇప్పటికే ఉన్న పనికి అనుగుణంగా ఉన్నప్పుడు మాత్రమే ఇది చేస్తుంది – అనగా, ఇది పుష్-బేస్డ్ కంటే ఎక్కువ పుల్-బేస్డ్. మేము ఎంటర్ నొక్కినప్పుడు, సిస్టమ్ మొదటి నేపథ్య ప్రక్రియ ముగిసిందని, లేదా అది ఆపివేయబడిందని / చంపబడిందని మాకు తెలియజేస్తుంది; [1]+ Killed gnome-calculator.

మాది తిరిగి kill command, సిగ్నల్ 9 kill ఇది చాలా విధ్వంసక హత్యలలో ఒకటి. అతను ప్రాథమికంగా మర్యాద లేకుండా అక్కడికక్కడే కార్యక్రమాన్ని ముగించాడు. మీరు యాక్సెస్ చేయగల “ప్రామాణిక సిగ్నల్స్ కోసం సిగ్నల్ నంబరింగ్” విభాగాన్ని సమీక్షించవచ్చు man signal.7 అందుబాటులో ఉన్న అన్ని సిగ్నల్స్ మరియు వాటి సంబంధిత సంఖ్యల జాబితా కోసం టెర్మినల్ కమాండ్ ప్రాంప్ట్ వద్ద కమాండ్ రన్.

ఈ వ్యాసం యొక్క ప్రయోజనాల కోసం, మేము ఉపయోగిస్తాము సిగ్నల్ 9 ఒక ప్రక్రియను వెంటనే మరియు సమర్థవంతంగా ముగించడానికి. అయితే, a ఉపయోగిస్తున్నప్పుడు కూడా సిగ్నల్ 9 చంపడం / ప్రాసెస్ చేయడం, కొన్నిసార్లు ఒక ప్రక్రియ ఫైల్‌లో కొనసాగుతుంది మరణించిన రాష్ట్రం.

సాధారణ DevOps పనిలో ఇది తరచుగా జరగదు, మరియు అది జరిగితే, సాధారణంగా సిస్టమ్ హార్డ్‌వేర్ లేదా ఆపరేటింగ్ సిస్టమ్‌తో ప్రారంభించడానికి ప్రోగ్రామ్ కోడ్ (రన్నింగ్ ప్రాసెస్) లో కొన్ని తీవ్రమైన సమస్యలు ఉన్నాయని అర్థం.

లోపాలను నివారించండి మరియు యాజమాన్య ప్రక్రియలను మాత్రమే ఎంచుకోండి

పై ప్రక్రియతో ప్రారంభించి, ఫైల్‌ను ఆటోమేట్ చేయడానికి ఒక మార్గం ఉంది PID ఎంపిక కాబట్టి మనం మాన్యువల్‌గా టైప్ చేయనవసరం లేదు, ఆపై దాన్ని స్క్రిప్ట్ నుండి ఉపయోగించవచ్చా? ఖచ్చితంగా ఉంది;

gnome-calculator &
ps -ef | grep 'gnome-calculator' | grep -v 'grep' | awk '{print $2}'
ps -ef | grep 'gnome-calculator' | grep -v 'grep' | awk '{print $2}' | xargs kill -9

Linux లో మరింత బాగా నిర్వచించబడిన ప్రక్రియ ముగింపు

ఇక్కడ మేము మళ్ళీ మాది ప్రారంభించాము gnome-calculator నేపథ్య మోడ్‌లో మరియు మళ్లీ ఉపయోగించబడుతుంది ps ఉంది grep మా ప్రక్రియను కనుగొనడానికి. ఇక్కడే సారూప్యత ముగుస్తుంది. బాష్ పైప్ సెట్‌లోని తదుపరి స్టేట్‌మెంట్‌లో (పైప్ చిహ్నాన్ని ఉపయోగించి మునుపటి ఆదేశం నుండి మరొకదానికి సమాచారాన్ని పంపడం: |) మేము మినహాయించాము grep ప్రాసెస్ కూడా (భాగంగా కూడా జాబితా చేయబడింది ps అవుట్పుట్ అది మా కమాండ్ సీక్వెన్స్ సమయంలో నడుస్తున్నప్పుడు మరియు స్వయంచాలకంగా గుర్తించబడుతుంది grep), పొడిగింపును ఉపయోగించి -v కోసం ఎంపిక grep మరియు పదాన్ని మినహాయించి 'grep'.

చివరగా, మేము ఫైల్ను ప్రింట్ చేస్తాము PID (ప్రాసెస్ ID) ఉపయోగించి కనుగొనబడిన అన్ని ప్రక్రియల awk మరియు రెండవదాన్ని ముద్రించడం ($2) అవుట్పుట్ యొక్క కాలమ్ మాత్రమే. మేము ఒక్కదాన్ని మాత్రమే చూస్తాము PID తిరిగి ఇవ్వబడింది, ఇది మనకు ఒకటి మాత్రమే ఉందనే దానికి అనుగుణంగా ఉంటుంది gnome-calculator ప్రారంభమైంది.

మా చివరి ఆదేశం ఒక ఫైల్‌ను జతచేస్తుంది xargs a తో ఆదేశం kill -9 మా ప్రక్రియలను ముగించే సూచనలు. xargs పైపు మాదిరిగానే పనిచేస్తుంది, కానీ వివిధ ఇన్పుట్ సమాచారాన్ని చక్కగా నిర్వహించగలదు మరియు దానిని సరిగ్గా పాస్ చేస్తుంది, కొన్ని ప్రోగ్రామ్‌లను అనుమతిస్తుంది kill (ఇది సరళంగా ఉన్నప్పుడు ఎవరు స్థానికంగా అర్థం చేసుకోలేరు PIDదీనికి పంపబడుతుంది) ప్రత్యక్ష ఇన్పుట్లను అంగీకరించడానికి, లేదా ఇక్కడ ఎంపిక చేసిన ప్రాసెస్ ఐడి వంటి ఎంపికలు. Xargs ఒక పైపు ముందు ఉంటుంది గమనించండి.

మా చేరిక a grep -v 'grep' ఇది చివరికి లోపం మాత్రమే కాకుండా kill కమాండ్ ఫైల్ను కనుగొనలేకపోయింది PID అసలుతో అనుబంధించబడింది grep ఆదేశం (ఇది అప్పటి నుండి ముగిసినప్పటి నుండి, దాని కోసం పట్టుకోవడం యొక్క విధిని నెరవేర్చిన తరువాత 'gnome-calculator' వచనం), రెండవది ఇది అసలు నుండి ప్రారంభమైన మరొక క్రొత్త ఆదేశం / ప్రక్రియను ముగించే ప్రమాదాన్ని కూడా నిరోధిస్తుంది grep అదే ప్రాసెస్ ID తో పూర్తయింది! ఇది జరిగే అవకాశం చిన్నది అయితే, అది సాధ్యమే.

మా ఆదేశంలో ఈ విషయాలను ఉపయోగించడం మంచిది, కానీ ఇది ఇంకా పరిపూర్ణంగా లేదు. ఇది 10 మంది వినియోగదారులతో సర్వర్ అంటే ఏమిటి మరియు మొత్తం 10 మంది కాలిక్యులేటర్‌ను ప్రారంభించారు? సుడోకు మనకు ఇలాంటి అధికారాలు ఉన్నాయని uming హిస్తే, ఇతర వినియోగదారుల గణన ప్రక్రియలను అంతం చేయాలనుకుంటున్నారా? బహుశా కాకపోవచ్చు. కాబట్టి, మనం ఒక అడుగు ముందుకు వేసి మన ఆదేశాన్ని ఈ క్రింది విధంగా నిర్వచించవచ్చు:

gnome-calculator &
ps -ef | grep 'gnome-calculator' | grep -v 'grep' | grep "$(whoami)" | awk '{print $2}'
ps -ef | grep 'gnome-calculator' | grep -v 'grep' | grep "$(whoami)" | awk '{print $2}' | xargs kill -9

ప్రాసెస్ టెర్మినేషన్ కమాండ్ నుండి యాజమాన్యంలోని ప్రక్రియలను మినహాయించడం

ఈ ఉదాహరణలో మేము ఒక చిన్న అదనపు ఆదేశాన్ని చేర్చాము grep "$(whoami)", ఇది సబ్‌షెల్ ప్రదర్శించింది ($(...)) ఆపై అది అమలు అవుతుంది whoami ఆ సబ్‌షెల్ లోపల. ది whoami కమాండ్ ప్రస్తుతం కనెక్ట్ చేయబడిన వినియోగదారులను టెర్మినల్‌కు తిరిగి ఇస్తుంది. బింగో! ఇప్పుడు మన యాజమాన్య ప్రక్రియలను పూర్తి చేద్దాం.

పర్ఫెక్ట్? లేదు, దురదృష్టవశాత్తు అటువంటి వివరణాత్మక కమాండ్ లైన్ ఉన్నప్పటికీ లోపాలు ఇప్పటికీ సాధ్యమే. ఉదాహరణకు, ప్రాసెస్ జాబితాలో స్థానిక లేదా బేసి అక్షరాలు ఉంటే, మాది grep ఇది ఇప్పటికీ విఫలం కావచ్చు. బహుశా సురక్షితమైన సంస్కరణ ఇలా ఉంటుంది:

gnome-calculator &
ps -ef | grep -Ei --binary-files=text "^$(whoami) [0-9 ]+:.*gnome-calculator$" | grep --binary-files=text -v 'grep' | awk '{print $2}' | grep --binary-files=text  -o '[0-9]+' | xargs -I{} kill -9 "{}"

మరింత సురక్షితమైన సంస్కరణ లేదా బహుళ-ప్రాసెస్ ముగింపు ఆదేశం

ఈ ఉదాహరణలో, మేము మాది నిర్వచించాము grep సాధారణ వ్యక్తీకరణతో మరింత నిరోధక ఆదేశం: ప్రారంభం (దీని ద్వారా సూచించబడుతుంది ^) వినియోగదారు పేరుతో (ఉపయోగించి whoami సబ్‌షెల్‌లో), అవసరమైన స్థలం తరువాత, అక్షరాలు మాత్రమే ఉంటాయి 0-9 మరియు స్థలం, కనీసం ఒకటి లేదా అంతకంటే ఎక్కువ (సూచించినట్లు) +), తరువాత తప్పనిసరి పెద్దప్రేగు (సమయం యొక్క భాగం), తరువాత మా ప్రోగ్రామ్ పేరు వరకు ఏదైనా అక్షరం ఉంటుంది, ఇది పంక్తి చివర వరకు నింపాలి (సూచించినట్లు) $). ది grep పొడిగించిన సాధారణ వ్యక్తీకరణలను ఉపయోగించండి (-E) మరియు కేస్ సెన్సిటివ్ కాదు (-i ఎంపిక, లేదా సరళంగా i ఉన్నదానికి జోడించినప్పుడు -E ఎంపిక)

స్థానిక లేదా బేసి అక్షరాలను ఉపయోగించే బేసి అవకాశం కోసం మేము మా grep ని కూడా రక్షించాము --binary-files=textమరియు మేము ప్రత్యామ్నాయ స్ట్రింగ్‌ను సూచించడం ద్వారా మరియు పున string స్థాపన స్ట్రింగ్‌ను ఉటంకిస్తూ మా xargs ను మరింత సురక్షితంగా వ్రాసాము.

చివరగా, మేము అదనపు ఫైల్ను చేర్చాము grep -o సంఖ్యల కోసం చూస్తున్న సాధారణ వ్యక్తీకరణతో 0-9 మాత్రమే. కాబట్టి కొన్ని ప్రోగ్రామ్ కమాండ్ లైన్‌ను చంపడం ద్వారా ఈ ప్రక్రియను మోసగించడానికి ప్రయత్నించినప్పటికీ, అలా చేయడం మరింత కష్టం.

పార్సింగ్ కమాండ్ లైన్‌ను నిర్వచించడానికి ఆసక్తికరమైన ప్రత్యామ్నాయంగా, మీరు కూడా పరిశీలించాలనుకోవచ్చు killall ఆదేశం:

gnome-calculator &
killall 'gnome-calculator'

కిల్లల్ ఆదేశాన్ని అమలు చేయడానికి ఉదాహరణ

ఈ ఆదేశంపై మరింత సమాచారం కోసం, మీరు మాన్యువల్ ఉపయోగించి యాక్సెస్ చేయవచ్చు man killall. ది killall వంటి ఎంపికలను సెట్ చేయడానికి కమాండ్ మిమ్మల్ని అనుమతిస్తుంది --user పేర్కొన్న వినియోగదారు యాజమాన్యంలోని ప్రక్రియలను మాత్రమే ముగించడం.

చుట్టి వేయు

ప్రాసెస్‌లను వివిధ మార్గాల్లో నిర్వహించడం ప్రాసెస్ వాచ్‌డాగ్ స్క్రిప్ట్‌లను వ్రాయడానికి, ప్రాసెస్ మేనేజ్‌మెంట్‌ను ఆటోమేట్ చేయడానికి, మల్టీ-థ్రెడ్ బాష్ కోడ్‌ను బాగా అభివృద్ధి చేయడానికి, ప్రాసెస్‌లను మెరుగ్గా నిర్వహించడానికి మరియు మరెన్నో అనుమతిస్తుంది. మీ క్రొత్త దొరికిన బాష్ నైపుణ్యాలను ఆస్వాదించండి!

Source link