Mga proseso sa Linux: ps, top, htop, kill, mga signal, at nice

Ang bawat programang tumatakbo sa Linux ay isang proseso na may sariling PID, may-ari, estado, at priority. Makikita ang mga proseso gamit ang ps, top, at htop, tinatapos gamit ang kill, at binabago ang priority gamit ang nice at renice. Narito ang pagbasa sa output ng mga command na ito, kung aling signal ang ipapadala kailan, at kung bakit hindi dapat unang gamitin ang kill -9.

Ano ang proseso at PID

Ang proseso ay programang nasa pagpapatakbo: code, memorya, mga bukas na file, at hanay ng mga katangian. Nagbibigay ang kernel ng natatanging PID sa bawat proseso, at itinatala rin nito ang PPID, ang numero ng magulang na nagpatakbo dito. Ang unang proseso sa sistema na may PID 1 ay kadalasang systemd, at ito ang “ninuno” ng lahat ng iba.

Dalawang hakbang ang paglikha ng bagong proseso. Una, tinatawag ng magulang ang fork() at nakakakuha ng sariling kopya; pagkatapos, tinatawag ng kopya ang execve() at pinapalitan ang sariling code ng code ng bagong programa. Kapag nagta-type ka ng ls sa terminal, ito mismo ang ginagawa ng bash, at naghihintay ito sa pagtatapos ng anak sa pamamagitan ng wait().

$ echo $$          # PID ng kasalukuyang shell
4182
$ ps -o pid,ppid,cmd -p $$
    PID    PPID CMD
   4182    4170 -bash

Paano tingnan ang mga proseso gamit ang ps

Gumagawa ang ps ng isang snapshot: ipinapakita ang mga proseso sa eksaktong sandali ng pagpapatakbo, at saka natatapos. Kapag walang argumento, ipinapakita lang nito ang mga proseso ng kasalukuyang terminal, kaya sa praktika ay halos palaging ginagamit ang isa sa dalawang bersyon.

$ 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

Ang a ay mga proseso ng lahat ng user, ang u ay detalyadong format na may may-ari, at ang x ay kasama ang mga prosesong walang terminal (daemon). Ang alternatibong sintaks na istilong System V ay ps -ef: ipinapakita nito ang PPID, na kapaki-pakinabang kapag kailangang malaman kung sino ang nagpatakbo kanino.

Mga kapaki-pakinabang na gamit ng ps

# nangungunang 10 ayon sa memorya
ps aux --sort=-%mem | head -11

# nangungunang 10 ayon sa processor
ps aux --sort=-%cpu | head -11

# sariling mga column
ps -eo pid,ppid,user,ni,stat,etime,cmd

# puno ng mga proseso
ps -ef --forest
pstree -p

# hanapin ang PID ayon sa pangalan
pgrep -a nginx
pidof nginx

Karaniwang pagkakamali ang paghahanap ng proseso gamit ang ps aux | grep nginx at makitang kasama sa output ang mismong grep. Gamitin ang pgrep o ang trick na grep [n]ginx, na hindi tumutugma sa sarili nitong command line.

Mga estado ng proseso: R, S, D, Z, T

Ang letra sa column na STAT ay hindi basura, kundi aktwal na estado ng proseso. Nakadepende rito kung paano bibigyang-kahulugan ang load, at kung makatutulong ba ang kill.

Kapaki-pakinabang din ang mga karagdagang simbolo pagkatapos ng letra: s — session leader, + — proseso sa foreground ng terminal, < — mataas na priority, N — mababang priority, l — multi-threaded.

Proseso sa estadong D

Ang prosesong nasa D ay nasa loob ng system call at naghihintay, halimbawa, ng tugon mula sa disk o sa natigil na NFS. Walang signal na naihahatid dito, kahit ang SIGKILL. Kaya walang silbi ang kill -9 dito: hanapin ang dahilan ng paghihintay — tingnan ang iostat, dmesg, at ang estado ng network storage.

Mga zombie na proseso

Patay na ang zombie: hindi ito gumagamit ng CPU o memorya, at isang linya lang ito sa talaan ng mga proseso. Hindi ito maaaring patayin, dahil tapos na ito. Mawawala ito kapag tinawag ng magulang ang wait(), o kapag natapos na ang magulang mismo at inampon ng PID 1 ang zombie.

# hanapin ang mga zombie at ang kanilang magulang
ps -eo pid,ppid,stat,cmd | awk '$3 ~ /Z/'

Walang panganib ang iisang zombie. Kung daan-daan na at patuloy na dumarami, may sira ang magulang na programa: kailangang ayusin o i-restart ito.

top: mga proseso at load sa real time

Ipinapakita ng top ang parehong listahan, pero nire-refresh ito tuwing ilang segundo at may buod ng sistema. Ito ang unang command na pinapatakbo kapag “bumabagal ang server”.

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

Pinakamahalaga ang linyang %Cpu(s): us — code ng user, sy — kernel, id — idle, wa — paghihintay sa disk. Mataas na wa habang libre ang processor ay malinaw na senyales na nasa I/O ang bottleneck.

Mga shortcut sa top

Para sa mga script at log, kapaki-pakinabang ang batch mode: ang top -b -n 1 | head -20 ay naglalabas ng isang snapshot nang walang interaksyon. Para bantayan ang isang partikular na proseso: top -p 1532.

Ang load average ay pila, hindi porsyento

Ang tatlong numero ng load average ay ang karaniwang haba ng pila sa nakaraang 1, 5, at 15 minuto. Sa Linux, kasama rito ang mga proseso sa estadong R at D, pero hindi ang karaniwang tulog na S. Ikumpara ang LA sa bilang ng core (nproc): sa 4 na core, ang halagang 4 ay buong load, at ang 12 ay pilang tatlong beses ang kapasidad.

Kung mataas ang LA habang nakatengga ang processor, hanapin ang mga proseso sa D: ps -eo stat,pid,cmd | grep '^D'. Halos palaging mabagal na disk o network storage ang dahilan.

htop: mas maginhawang kapalit ng top

Ipinapakita ng htop ang parehong impormasyon, pero may mga kulay na indicator sa bawat core, scroll, suporta sa mouse, at puno ng proseso. Karaniwang kailangan itong i-install: sudo apt install htop o sudo dnf install htop.

• F3 o / — hanapin ang proseso ayon sa pangalan;
• F4 — filter na nagpapakita lang ng mga tugma;
• F5 o t — puno ng “magulang — mga anak”;
• F6 — piliin ang column para sa pag-sort;
• F7 / F8 — bawasan o dagdagan ang nice;
• F9 — menu ng mga signal para sa napiling proseso;
• Space — markahan ang ilang proseso para sa sabayang aksyon.

Sa mga server na hindi puwedeng mag-install ng kahit ano, sapat na ang top: nandoon din ang lahat ng pangunahing operasyon.

Paano tapusin ang proseso: kill at mga signal

Hindi “pumapatay” ang kill, kundi nagpapadala ng signal sa proseso. Ang mangyayari pagkatapos ay nakadepende sa signal at sa paraan ng pag-handle nito ng programa.

Ang mga numero ay para sa x86 at ARM; ang kumpletong listahan ay makukuha sa kill -l. Mas maaasahan ang pagsulat ng signal sa pangalan kaysa sa numero.

kill 1532              # SIGTERM
kill -TERM 1532        # pareho, tahasan
kill -HUP $(pidof nginx)   # basahin ulit ang config
kill -STOP 1532; kill -CONT 1532
kill -0 1532 && echo "buhay pa ang proseso"

Ang signal na 0 ay walang ipinapadala, sinusuri lang nito kung umiiral ang proseso at kung may karapatan kang sumulat dito, kapaki-pakinabang sa mga script.

Bakit hindi dapat magsimula sa kill -9

Binibigyan ng SIGTERM ang programa ng pagkakataong isara ang mga file, i-flush ang buffer, burahin ang lock file, at tapusin nang tama ang mga transaksyon. Biglaang pinpuputol ng SIGKILL ang lahat: nawawala ang hindi pa naisusulat na datos, nananatili ang pansamantalang file, at maaaring pumasok sa recovery ang database sa susunod na pagsisimula.

Ganito ang tamang pagkakasunod-sunod:

1. Ipadala ang kill PID (SIGTERM).
2. Maghintay ng 5–30 segundo, habang sinusuri gamit ang kill -0 PID.
3. Kung buhay pa ang proseso at wala sa estadong D — saka lang kill -9 PID.

Para sa mga serbisyong nasa ilalim ng systemd, mas mabuting huwag na lang galawin ang PID nang mano-mano: ang systemctl stop na mismo ang magpapadala ng SIGTERM, maghihintay sa timeout, at saka tatapusin gamit ang SIGKILL.

pkill at killall: ayon sa pangalan

pkill -f "python worker.py"   # ayon sa buong command line
pkill -u alice                 # lahat ng proseso ng user
killall -TERM node             # lahat ng prosesong may pangalang node
pgrep -l -f worker             # unang tingnan kung ano ang tatamaan ng pattern

Bago ang maramihang pkill, laging patakbuhin ang pgrep gamit ang parehong pattern: ang -f ay tumutugma sa anumang bahagi ng command line, kaya madali nitong masasagap ang hindi dapat.

Ang sarili mo lang na proseso ang maaari mong padalhan ng signal; para sa iba, kailangan ang sudo. Ang error na Operation not permitted ay nangangahulugang ganito nga.

Priority ng proseso: nice at renice

Sinasabi ng value ng nice sa scheduler kung sino ang dapat magbigay-daan sa processor. Ang saklaw ay mula -20 (pinakamataas na priority) hanggang 19 (nagbibigay-daan sa lahat), at ang default ay 0. Nakikita ito sa column na NI sa top, habang ang PR ay ang panloob at hinango na priority.

# patakbuhin ang mabigat na gawain nang mababa ang priority
nice -n 10 tar czf backup.tar.gz /var/www

# ibaba ang priority ng tumatakbong proseso
renice -n 15 -p 1532

# itaas (root lang)
sudo renice -n -5 -p 1610

# lahat ng proseso ng user
sudo renice -n 10 -u alice

Ang ordinaryong user ay maaari lang magbaba ng priority ng sarili niyang proseso; ang negatibong halaga ay para lang sa root. Mahalagang tandaan na ang nice ay nakaaapekto lang sa CPU. Kung pinapabagal ng gawain ang sistema sa disk, gamitin ang ionice -c3 command — ang klase na idle, na nakakakuha lang ng disk kapag walang ibang gumagamit nito.

Background na proseso at job ng shell

Maaaring patakbuhin ang command sa background sa pamamagitan ng pagdagdag ng &, o pansamantalang ihinto sa Ctrl+Z. Nagtatala ang shell ng listahan ng mga job, na kinokontrol ng mga built-in na command.

$ long_task &
[1] 5120
$ jobs
[1]+  Running    long_task &
$ fg %1        # ibalik sa foreground
^Z             # ihinto (SIGTSTP)
$ bg %1        # ituloy sa background

Kapag isinara ang terminal, nagpapadala ang shell ng SIGHUP sa mga job, at natatapos ang mga ito. Para mabuhay ang proseso pagkatapos lumabas, patakbuhin ito gamit ang nohup command &, ihiwalay gamit ang disown, o gamitin ang tmux. Para sa tuluy-tuloy na pagtakbo, mas tama itong gawing serbisyo ng systemd.

Mga karaniwang senaryo ng diagnosis

Sino ang kumakain ng processor

top -o %CPU            # o P sa loob ng top
ps -eo pid,user,%cpu,etime,cmd --sort=-%cpu | head

Kung kumakain ng CPU nang walang silbi ang isang proseso, ibaba muna ang priority nito gamit ang renice. Ligtas ito at nagbibigay ng oras para alamin ang sanhi.

Sino ang kumuha ng port

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

Ilalabas ng output ang PID, at mula roon, makikita sa /proc/PID/ ang executable (exe), ang working directory (cwd), at ang mga argumento (cmdline).

Biglang nawala ang proseso

Karaniwang dahilan ang OOM Killer, na pumapatay ng mga proseso kapag kulang ang memorya. Pagsusuri: dmesg -T | grep -i oom o journalctl -k | grep -i "killed process".

Buod

Para sa pagtatrabaho sa mga proseso sa Linux, sapat na ang maliit na hanay ng mga command: ps aux para sa snapshot, top at htop para sa pagmamasid, kill na may tamang signal para sa pagtatapos, at nice/renice para sa priority. Basahin muna ang estado ng proseso bago kumilos: hindi nalulutas ng signal ang zombie at ang mga proseso sa D. At magsimula palagi sa SIGTERM, itira ang kill -9 para sa huling pagkakataon. Ang mga proseso, memorya, load average, at system call ay tinalakay nang praktikal sa kurso sa Linux.