Linux में प्रोसेस: ps, top, htop, kill, सिग्नल और nice

Linux में हर चलता कार्यक्रम एक प्रोसेस है, जिसका अपना PID नंबर, मालिक, स्थिति और प्राथमिकता होती है। प्रोसेस ps, top और htop से देखे जाते हैं, kill से बंद होते हैं, और nice व renice से उनकी प्राथमिकता बदलती है। नीचे देखेंगे कि इन कमांड के आउटपुट कैसे पढ़ें, कौन-सा सिग्नल कब भेजें, और क्यों kill -9 पहली प्रतिक्रिया नहीं होनी चाहिए।

प्रोसेस और PID क्या है

प्रोसेस यानी चल रहा प्रोग्राम: कोड, मेमोरी, खुली फ़ाइलें और कुछ गुण। कर्नल हर प्रोसेस को एक अनोखा PID देता है, और साथ ही PPID भी याद रखता है, यानी उसके जनक (parent) का नंबर जिसने उसे शुरू किया। सिस्टम की पहली प्रोसेस PID 1 होती है, आम तौर पर systemd, और यही बाक़ी सबकी «जनक» बनती है।

नई प्रोसेस दो चरणों में बनती है। पहले पैरेंट fork() कॉल करके अपनी एक प्रति बनाता है, फिर वह प्रति execve() कॉल करके अपना कोड नए प्रोग्राम के कोड से बदल देती है। जब आप टर्मिनल में ls टाइप करते हैं, तो bash यही करता है और wait() से चाइल्ड के ख़त्म होने का इंतज़ार करता है।

$ echo $$          # मौजूदा shell का PID
4182
$ ps -o pid,ppid,cmd -p $$
    PID    PPID CMD
   4182    4170 -bash

ps कमांड से प्रोसेस कैसे देखें

ps एक बार का स्नैपशॉट लेता है: उसी क्षण की प्रोसेस दिखाता है और ख़त्म हो जाता है। बिना आर्गुमेंट के यह केवल मौजूदा टर्मिनल की प्रोसेस दिखाता है, इसलिए व्यवहार में लगभग हमेशा इन दोनों में से एक रूप इस्तेमाल होता है।

$ ps aux | head -5
USER       PID %CPU %MEM    VSZ   RSS TTY   STAT START   TIME COMMAND
root         1  0.0  0.3 168540 12780 ?     Ss   09:12   0:03 /sbin/init
root         2  0.0  0.0      0     0 ?     S    09:12   0:00 [kthreadd]
www-data  1532  1.2  2.1 412308 86420 ?     S    09:15   1:47 php-fpm: pool www
postgres  1610  0.4  3.8 221004 154312 ?    Ss   09:15   0:31 postgres: checkpointer

यहाँ a का मतलब सभी यूज़र की प्रोसेस, u का मतलब मालिक के साथ विस्तृत फ़ॉर्मेट, और x का मतलब वे प्रोसेस भी जिनका कोई टर्मिनल नहीं है (डेमन)। System V शैली का विकल्प है ps -ef, जो PPID दिखाता है। यह तब काम आता है जब समझना हो कि किसने किसे शुरू किया।

ps के उपयोगी तरीक़े

# मेमोरी के हिसाब से शीर्ष 10
ps aux --sort=-%mem | head -11

# प्रोसेसर के हिसाब से शीर्ष 10
ps aux --sort=-%cpu | head -11

# अपने कॉलम चुनें
ps -eo pid,ppid,user,ni,stat,etime,cmd

# प्रोसेस का पेड़
ps -ef --forest
pstree -p

# नाम से PID खोजें
pgrep -a nginx
pidof nginx

एक आम गलती है ps aux | grep nginx से प्रोसेस खोजना, और आउटपुट में ख़ुद grep का आ जाना। इसकी जगह pgrep लें, या grep [n]ginx की चाल चलें, जो अपनी ही कमांड-लाइन से मेल नहीं खाती।

प्रोसेस की स्थितियाँ: R, S, D, Z, T

STAT कॉलम का अक्षर बेकार का चिह्न नहीं, प्रोसेस की असली स्थिति है। उसी से तय होता है कि लोड को कैसे समझें और क्या kill से कुछ हो सकता है।

अक्षर के बाद के चिह्न भी काम के हैं: s — सेशन लीडर, + — टर्मिनल की अग्रभूमि प्रोसेस, < — ऊँची प्राथमिकता, N — नीची प्राथमिकता, l — मल्टी-थ्रेडेड।

स्थिति D वाली प्रोसेस

D में प्रोसेस एक सिस्टम कॉल के भीतर होती है और, उदाहरण के लिए, डिस्क या अटके हुए NFS के जवाब का इंतज़ार करती है। उस पर कोई सिग्नल नहीं पहुँचता, SIGKILL भी नहीं। इसलिए यहाँ kill -9 बेकार है: इंतज़ार की असली वजह खोजें, iostat, dmesg और नेटवर्क स्टोरेज की हालत देखें।

Zombie प्रोसेस

Zombie पहले ही मर चुकी है: वह CPU या मेमोरी नहीं लेती, बस प्रोसेस तालिका में एक पंक्ति घेरती है। उसे मारा नहीं जा सकता, क्योंकि वह पहले ही ख़त्म है। वह तब हटती है जब पैरेंट wait() कॉल करे, या जब पैरेंट ख़ुद ख़त्म हो और zombie को PID 1 गोद ले ले।

# zombie और उनके पैरेंट खोजें
ps -eo pid,ppid,stat,cmd | awk '$3 ~ /Z/'

अकेला zombie नुकसानदेह नहीं। अगर उनकी संख्या सैकड़ों में हो और बढ़ रही हो, तो गड़बड़ी पैरेंट प्रोग्राम में है: उसे ठीक करें या रीस्टार्ट करें।

top: प्रोसेस और लोड रियल टाइम में

top वही सूची दिखाता है, पर उसे हर कुछ सेकंड में अपडेट करता है और ऊपर सिस्टम का सारांश देता है। जब «सर्वर धीमा है» तो यही पहली कमांड चलाई जाती है।

top - 14:21:07 up 12 days,  3:02,  2 users,  load average: 1.84, 1.20, 0.95
Tasks: 213 total,   2 running, 211 sleeping,   0 stopped,   0 zombie
%Cpu(s): 23.1 us,  4.2 sy,  0.0 ni, 70.3 id,  1.9 wa,  0.0 hi,  0.5 si,  0.0 st
MiB Mem :   7821.4 total,    412.6 free,   3105.8 used,   4303.0 buff/cache
MiB Swap:   2048.0 total,   2048.0 free,      0.0 used.   4398.2 avail Mem

    PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
   1532 www-data  20   0  412308  86420  14212 R  38.2   1.1   1:47.31 php-fpm
   1610 postgres  20   0  221004 154312 148900 S   6.0   1.9   0:31.08 postgres

%Cpu(s) की लाइन सबसे ज़रूरी है: us — यूज़र कोड, sy — कर्नल, id — ख़ाली, wa — डिस्क का इंतज़ार। प्रोसेसर ख़ाली हो और wa ऊँचा हो, तो रुकावट I/O में है।

top की शॉर्टकट कुंजियाँ

स्क्रिप्ट और लॉग के लिए बैच मोड काम का है: top -b -n 1 | head -20 बिना इंटरैक्शन के एक स्नैपशॉट देता है। किसी एक प्रोसेस पर नज़र रखने के लिए top -p 1532।

Load Average एक कतार है, प्रतिशत नहीं

load average की तीन संख्याएँ 1, 5 और 15 मिनट की औसत कतार की लंबाई हैं। Linux में इसमें R और D स्थिति की प्रोसेस गिनी जाती हैं, सामान्य नींद S नहीं। LA की तुलना कोर की संख्या (nproc) से करें: 4 कोर पर मान 4 यानी पूरी लोड, और 12 यानी क्षमता से तीन गुना कतार।

अगर LA ऊँचा हो और प्रोसेसर ख़ाली, तो D वाली प्रोसेस खोजें: ps -eo stat,pid,cmd | grep '^D'। लगभग हमेशा यह धीमी डिस्क या नेटवर्क स्टोरेज होता है।

htop: top का सुविधाजनक विकल्प

htop वही दिखाता है, पर रंगीन कोर-संकेतकों, स्क्रॉलिंग, माउस सपोर्ट और प्रोसेस-पेड़ के साथ। आम तौर पर इसे इंस्टॉल करना पड़ता है: sudo apt install htop या sudo dnf install htop।

• F3 या / — नाम से प्रोसेस खोजना;
• F4 — फ़िल्टर, केवल मेल खाने वाली प्रोसेस दिखाता है;
• F5 या t — «पैरेंट — चाइल्ड» पेड़;
• F6 — क्रम के लिए कॉलम चुनना;
• F7 / F8 — nice घटाना या बढ़ाना;
• F9 — चुनी प्रोसेस के लिए सिग्नल मेनू;
• Space — कई प्रोसेस चुनकर एक साथ कार्य।

जिन सर्वर पर कुछ इंस्टॉल नहीं कर सकते, वहाँ top काफ़ी है: उसमें भी ये सारे मुख्य काम हैं।

प्रोसेस कैसे बंद करें: kill और सिग्नल

kill असल में «मारता» नहीं, प्रोसेस को एक सिग्नल भेजता है। आगे क्या होगा, यह सिग्नल पर और इस पर निर्भर है कि प्रोग्राम उसे कैसे संभालता है।

नंबर x86 और ARM के लिए दिए गए हैं; पूरी सूची kill -l दिखाता है। सिग्नल का नाम लिखना नंबर से ज़्यादा भरोसेमंद है।

kill 1532              # SIGTERM
kill -TERM 1532        # वही, साफ़ लिखकर
kill -HUP $(pidof nginx)   # कॉन्फ़िग दोबारा पढ़वाना
kill -STOP 1532; kill -CONT 1532
kill -0 1532 && echo "प्रोसेस ज़िंदा है"

सिग्नल 0 कुछ नहीं भेजता, केवल जाँचता है कि प्रोसेस मौजूद है या नहीं और क्या आपको उसे सिग्नल भेजने का अधिकार है। स्क्रिप्ट में यह उपयोगी है।

kill -9 से शुरू क्यों नहीं करना चाहिए

SIGTERM प्रोग्राम को मौक़ा देता है कि वह फ़ाइलें बंद करे, बफ़र लिखे, lock-फ़ाइलें हटाए और ट्रांज़ैक्शन सही ढंग से पूरे करे। SIGKILL सब कुछ तुरंत काट देता है: अधूरा लिखा डेटा खो जाता है, अस्थायी फ़ाइलें बची रह जाती हैं, और डेटाबेस अगली बार शुरू होने पर रिकवरी में जा सकता है।

सही क्रम यह है:

1. kill PID भेजें (SIGTERM)।
2. 5–30 सेकंड रुकें, और kill -0 PID से जाँचते रहें।
3. तभी kill -9 PID, जब प्रोसेस अब भी ज़िंदा हो और D स्थिति में न हो।

systemd की सेवाओं के लिए PID को हाथ से न छुएँ: systemctl stop ख़ुद SIGTERM भेजता है, समय-सीमा तक रुकता है, फिर SIGKILL से पूरा करता है।

pkill और killall: नाम से

pkill -f "python worker.py"   # पूरी कमांड-लाइन से
pkill -u alice                 # यूज़र की सभी प्रोसेस
killall -TERM node             # नाम node वाली सभी प्रोसेस
pgrep -l -f worker             # पहले देखें कि पैटर्न में क्या आएगा

थोक में pkill से पहले वही पैटर्न pgrep में चलाएँ: -f कमांड-लाइन के किसी भी हिस्से से मेल खाता है और आसानी से कुछ ग़लत भी पकड़ सकता है।

सिग्नल केवल अपनी प्रोसेस को भेजे जा सकते हैं; दूसरों की प्रोसेस के लिए sudo चाहिए। Operation not permitted त्रुटि का यही मतलब है।

प्रोसेस की प्राथमिकता: nice और renice

nice मान शेड्यूलर को बताता है कि कौन प्रोसेसर किसे दे। सीमा -20 (सबसे ऊँची प्राथमिकता) से 19 (सबको जगह देना) तक है, डिफ़ॉल्ट 0। top में यह NI कॉलम में दिखता है, जबकि PR उससे निकला आंतरिक मान है।

# भारी काम को कम प्राथमिकता से चलाना
nice -n 10 tar czf backup.tar.gz /var/www

# चल रही प्रोसेस की प्राथमिकता घटाना
renice -n 15 -p 1532

# प्राथमिकता बढ़ाना (केवल root)
sudo renice -n -5 -p 1610

# यूज़र की सभी प्रोसेस
sudo renice -n 10 -u alice

सामान्य यूज़र अपनी प्रोसेस की प्राथमिकता केवल घटा सकता है; ऋणात्मक मान केवल root के लिए हैं। ध्यान रखें कि nice केवल CPU पर असर डालता है। अगर कोई काम डिस्क से सिस्टम को धीमा कर रहा है, तो ionice -c3 कमांड इस्तेमाल करें: यह idle क्लास है, जिसे डिस्क तभी मिलती है जब उसकी ज़रूरत किसी को न हो।

बैकग्राउंड प्रोसेस और shell के जॉब

कमांड को & लगाकर बैकग्राउंड में चलाया जा सकता है, या Ctrl+Z से रोका जा सकता है। Shell जॉब की सूची रखता है, जिसे built-in कमांड से संभाला जाता है।

$ long_task &
[1] 5120
$ jobs
[1]+  Running    long_task &
$ fg %1        # अग्रभूमि में वापस लाएँ
^Z             # रोकें (SIGTSTP)
$ bg %1        # बैकग्राउंड में चलाएँ

टर्मिनल बंद होने पर shell जॉब को SIGHUP भेजता है, और वे ख़त्म हो जाते हैं। टर्मिनल बंद होने के बाद भी प्रोसेस चलती रहे, इसके लिए nohup कमांड & चलाएँ, disown से जॉब को shell से अलग करें, या tmux इस्तेमाल करें। लगातार चलने वाले काम के लिए सही तरीक़ा है उसे systemd सेवा बनाना।

आम जाँच के तरीक़े

CPU किसने खाया

top -o %CPU            # या top के अंदर P
ps -eo pid,user,%cpu,etime,cmd --sort=-%cpu | head

अगर कोई प्रोसेस बेकार में CPU खा रही है, तो पहले renice से उसकी प्राथमिकता घटाएँ। यह सुरक्षित है और समझने का समय देता है।

पोर्ट किसने घेरा

sudo ss -ltnp | grep :8080
sudo lsof -i :8080

आउटपुट में PID होगा, और उसी से /proc/PID/ में चलने वाली फ़ाइल (exe), कार्यरत डायरेक्टरी (cwd) और आर्गुमेंट (cmdline) मिल जाते हैं।

प्रोसेस अचानक ग़ायब हो गई

एक आम कारण OOM Killer है, जो मेमोरी कम पड़ने पर प्रोसेस मार देता है। जाँच: dmesg -T | grep -i oom या journalctl -k | grep -i "killed process"।

निष्कर्ष

Linux में प्रोसेस के लिए थोड़ी-सी कमांड काफ़ी हैं: स्नैपशॉट के लिए ps aux, निगरानी के लिए top और htop, बंद करने के लिए सही सिग्नल वाला kill, और प्राथमिकता के लिए nice/renice। कार्रवाई से पहले प्रोसेस की स्थिति पढ़ें: zombie और D स्थिति वाली प्रोसेस सिग्नल से ठीक नहीं होतीं। शुरुआत SIGTERM से करें, और kill -9 को आख़िरी उपाय रखें। प्रोसेस, मेमोरी, Load Average और सिस्टम कॉल पर हमारे Linux कोर्स में व्यवहार में विस्तार से काम होता है।