htop/ps — Process Management Tools

Q: What is the difference between ps aux and ps -ef?

Both show all processes but differ in output format: ps aux uses BSD style (USER/PID/%CPU/%MEM/VSZ/RSS/TTY/STAT/START/TIME/COMMAND) while ps -ef uses System V style (UID/PID/PPID/C/STIME/TTY/TIME/CMD). ps aux includes CPU and memory percentages, making it better for resource analysis.

Q: Which is better, htop or top?

htop is a modern replacement for top with a color interface, mouse support, vertical/horizontal scrolling, tree view (F5), and intuitive filtering (F4) and searching (F3). htop is typically pre-installed on modern systems. Use htop daily but rely on top in minimal environments or scripts.

Q: How do I forcefully kill a stuck process?

First try SIGTERM (kill -15) for graceful termination. If that fails after a few seconds, use SIGKILL (kill -9). If the process is a zombie (Z state), you must kill its parent (PPID). Use pkill to match by name pattern, or killall to terminate all processes with a given name.

Q: What is the difference between nohup and disown?

nohup starts a process that ignores HUP signals and redirects output to nohup.out automatically. disown removes an already-running job from the shell's job table, protecting it from terminal closure. A common workflow: start process, Ctrl+Z to suspend, bg to background, then disown.

Q: What is the difference between strace and ltrace?

strace traces system calls (open, read, write, ioctl) — ideal for analyzing kernel interactions, file operations, and performance bottlenecks. ltrace traces library function calls (printf, malloc, strcpy) — useful for analyzing userspace library usage. Both support -p to attach to running processes.

Linux process management is an essential skill for all ops and developers. This cheatsheet covers everything from basic `ps` viewing to advanced `strace` syscall tracing, along with `htop` real-time monitoring, signal sending, priority adjustment, and more.

Updated: 2026-07-17·31 commands

Overview

Process management is a fundamental skill for Linux system administration. This cheatsheet covers process monitoring, signal handling, priority management, and real-time system monitoring.

Quick Start

``bash ps aux | grep nginx # Find nginx processes top # Interactive process viewer kill -15 PID # Gracefully terminate a process``

Refer to the command table below for detailed usage.

Process View(8)

Command	Level	Example
`ps aux` Show all processes for all users (BSD style)	Basic	`ps aux \| grep nginx`
`ps -ef` Show all processes (System V style)	Basic	`ps -ef \| grep java`
`ps -u` Show processes for a specific user	Basic	`ps -u www-data`
`ps --forest` Display process hierarchy as a tree	Intermediate	`ps aux --forest`
`pstree` Display processes as a tree diagram	Basic	`pstree -p 1234`
`pgrep` Look up process IDs by name	Intermediate	`pgrep -u www-data nginx`
`lsof` List open files and network connections by process	Intermediate	`lsof -i :8080`
`w` Show who is logged on and what they are doing	Basic	`w`

Monitoring(9)

Command	Level	Example
`top` Display real-time process activity (sorted by CPU by default)	Basic	`top -u mysql`
`htop` Enhanced real-time process monitor	Basic	`htop -p 1234,5678`
`screen` Terminal multiplexer (persists sessions)	Intermediate	`screen -S mysession`
`strace` Trace system calls and signals	Expert	`strace -p 1234 -e trace=open,read`
`watch` Periodically execute a command	Basic	`watch -n 2 'ps aux --sort=-%cpu \| head -10'`
`uptime` Show system uptime and load averages	Basic	`uptime`
`free` Display system memory usage	Basic	`free -h`
`vmstat` Report virtual memory statistics	Intermediate	`vmstat 2 5`
`iostat` Report input/output statistics	Intermediate	`iostat -x 2`

Signals(10)

Command	Level	Example
`kill` Send a signal to a process	Basic	`kill -15 1234`
`killall` Kill all processes matching a name	Intermediate	`killall -9 nginx`
`pkill` Match by name or attribute and send signal	Intermediate	`pkill -f "python script.py"`
`kill -l` List all available signal names	Intermediate	`kill -l`
`nohup` Run a process immune to hangups	Intermediate	`nohup long-running.sh &`
`disown` Remove a job from the shell's job table	Intermediate	`disown %1`
`bg` Resume a suspended job in the background	Basic	`bg %2`
`fg` Bring a background job to the foreground	Basic	`fg %1`
`jobs` List background jobs of the current shell	Basic	`jobs -l`
`timeout` Run a command with a time limit	Intermediate	`timeout 30 ./long-task.sh`

Priority(4)

Command	Level	Example
`nice` Start a process with a specified priority	Intermediate	`nice -n 10 ./backup.sh`
`renice` Change the priority of a running process	Intermediate	`renice -n 5 -p 1234`
`taskset` Set or retrieve a process's CPU affinity	Expert	`taskset -pc 0-3 1234`
`ionice` Set or retrieve I/O scheduling priority	Expert	`ionice -c 2 -n 7 -p 1234`

FAQ

What is the difference between ps aux and ps -ef?

Which is better, htop or top?

How do I forcefully kill a stuck process?

What is the difference between nohup and disown?

What is the difference between strace and ltrace?

This cheatsheet is compiled from official tool documentation. Last updated: 2026-07-17.