// learn Β· linux Β· rhcsa Β· 10 min

Processes and signals.

Every running program is a process with a PID, a parent, an owner, and a state. Watch a process move through its five states, learn the signals that push it between them, and the difference between asking it to stop and forcing it.

Linux processes and signals animated tutorial. Process anatomy, the five process states (running, sleeping, uninterruptible, stopped, zombie), job control, the signal catalog, SIGTERM vs SIGKILL, kill/pkill/killall, and nice/renice priority. RHCSA EX200 ready.
// processes and signals

A process is a running program the kernel tracks by PID. It's always in one of five states, and signals are how you (and the kernel) push it between them.

// before you start
you should know
  • Β·Comfortable running commands and reading output at the shell
  • Β·Helpful: the command-line essentials lesson (pipes, ps | grep)
  • Β·Know roughly what 'the CPU' and 'I/O' mean
by the end you'll

Read the STAT column, name the five states, use job control, send the right signal (15 before 9), and adjust priority with nice/renice.

pace: 10 minutes

process states β€” step 1 / 6 Β· anatomy
fork + execwait I/Owakeblocked in kernelSIGSTOP / Ctrl-ZSIGCONT / fg / bgexit / SIGTERM / SIGKILLreapedRR Β· runningTT Β· stoppedSS Β· sleepingDD Β· uninterruptibleZZ Β· zombie

A process is a running program with an identity

When you launch a program, the kernel creates a process: a PID (its unique number), a PPID (its parent β€” every process except PID 1 has one), an owner (UID), a state, and the command line. PID 1 is the init system (systemd). `ps` and `top` show all of this. A fresh process is in the Running/Runnable state, R.

$ps aux
$ps -ef
$top / htop
$pgrep -a nginx
// key insight

The golden rule of killing things: ask nicely, then force. Send SIGTERM (plain kill) first and give the process a couple of seconds to clean up. Only escalate to SIGKILL (-9) if it's unresponsive. Reaching for -9 first is a habit that leaves corrupt files, stale locks, and half-written state behind.

// exam-ready Β· inspect, control, signal, prioritize
$ps aux / ps -ef
$ps -o pid,ppid,stat,ni,comm
$top / htop
$pgrep -a sshd
$pstree -p
$kill 1234
$kill -9 1234
$kill -HUP 1234
$kill -l
$pkill -f pattern
$killall firefox
$jobs / fg / bg
$nohup cmd & ; disown
$nice -n 10 cmd
$renice -n 5 -p 1234
$/proc/<pid>/status
// check yourself
4 quick questions
Q1

A process is stuck in state D (uninterruptible sleep) and `kill -9` does nothing. Why?

Q2

What's the difference between SIGTERM (15) and SIGKILL (9)?

Q3

What is a zombie (Z-state) process?

Q4

As a regular (non-root) user, you try `renice -n -5 -p 1234` and it's denied. Why?

These aren't graded β€” they're just for active recall, which is what actually makes the lesson stick.

βš™οΈ
// explore it

Process explorer

Browse a sample process tree, see PIDs, states, and resource use, and practice picking the right signal β€” without touching a real system.

open β†’
// more in linux

keep going β€” these pair well with what you just learned.

see all linux β†’
back to RHCSA trackall lessons