Mastering Process Management in Linux (2025): Ultimate Guide From System Monitoring to DevOps Automation

# Quick system health check focusing on problematic states
echo "=== Zombie Processes ==="
ps aux | awk '$8 ~ /^Z/ { print $2, $11 }' | wc -l

echo "=== Uninterruptible Sleep (System Stress) ==="
ps aux | awk '$8 ~ /^D/ { print $2, $11, $10 }'

echo "=== High CPU Processes ==="
ps aux --sort=-%cpu | head -5

# Basic comprehensive process listing
ps aux

# Show process tree hierarchy (crucial for containers)
ps auxf

# Identify memory hogs affecting deployment pipelines
ps aux --sort=-%mem | head -10

# Find CPU-intensive processes impacting build performance
ps -eo pid,ppid,cmd,%mem,%cpu --sort=-%cpu | head -15

# Track containerized application hierarchies
ps axjf | grep -A 10 -B 5 "docker\|containerd"

# Monitor specific services by name
ps -C nginx,redis-server,postgresql -o pid,ppid,cmd,%mem,%cpu

# Custom formatting for automation
ps -eo pid,ppid,cmd,pcpu,pmem --no-headers

# Find processes by name pattern
ps aux | grep nginx
pgrep -f "python.*celery.*worker"  # More efficient alternative

ps aux --sort=-%mem | head && iostat -x 1 3

# Find processes by name
pgrep nginx
pgrep -f "ansible-playbook"  # Match full command line

# Display process details with names
pgrep -l python
pgrep -fa "docker.*build"  # Full command line with arguments

# Find processes by user (useful for container namespaces)
pgrep -u root
pgrep -u $(id -u docker)

# Kill processes by pattern
pkill firefox
pkill -f "python.*celery.*worker"

# Kill processes owned by specific user
pkill -u username

# Graceful shutdown with signal specification
pkill -TERM -f "nginx.*worker"

# Process status and details
cat /proc/PID/status

# Memory mappings (useful for memory leak investigation)
cat /proc/PID/maps

# Open files and file descriptors
ls -la /proc/PID/fd/

# Command line arguments
cat /proc/PID/cmdline | tr '\0' ' '

# Environment variables
cat /proc/PID/environ | tr '\0' '\n'

# Current working directory
ls -la /proc/PID/cwd

# Resource limits
cat /proc/PID/limits

# Graceful shutdown for web services (allows connection draining)
kill -TERM $(pidof nginx)
sleep 10
kill -KILL $(pidof nginx) 2>/dev/null || echo "Clean shutdown successful"

# Force kill processes blocking deployment ports
kill -9 $(lsof -t -i:8080)

# Bulk process management for service restarts
pkill -f "python.*celery.*worker" -TERM
sleep 5
pkill -f "python.*celery.*worker" -KILL 2>/dev/null

# Safe database shutdown
sudo systemctl stop postgresql
# Or if managing manually:
kill -TERM $(cat /var/lib/postgresql/data/postmaster.pid)

# Replicate Docker's shutdown behavior
timeout 30 sh -c 'kill -TERM $1 && wait $1' -- $PID || kill -KILL $PID

# Interrupt Maven/Gradle builds cleanly
pkill -f "java.*maven" -INT
pkill -f "java.*gradle" -INT

# Run low-priority backups without impacting production
nice -n 15 /opt/backup/daily-backup.sh

# Prioritize critical monitoring processes
renice -n -10 -p $(pgrep prometheus)
renice -n -10 -p $(pgrep grafana-server)

# Boost priority for time-sensitive deployments
renice -n -5 -p $(pgrep ansible-playbook)

# Lower priority for resource-intensive builds during business hours
renice -n 10 -p $(pgrep "docker.*build")

# Container-aware priority management
nsenter -t $(docker inspect -f '{{.State.Pid}}' $CONTAINER_ID) -p \
  renice -n -5 -p $(pgrep your_critical_app)

# Basic real-time monitoring
top

# Sort by memory usage
top -o %MEM

# Show specific user processes
top -u username

# Batch mode for scripting
top -b -n 1

# Show individual CPU cores
top -1

# Install htop
sudo apt install htop  # Ubuntu/Debian
sudo yum install htop  # RHEL/CentOS

# Launch with DevOps-friendly settings
htop -d 10 -H --sort-key=PERCENT_CPU

# Install sysstat package
sudo apt install sysstat

# Show CPU usage per process
pidstat 1

# Show memory usage per process
pidstat -r 1

# Show I/O statistics per process
pidstat -d 1

# Monitor specific process
pidstat -p PID 1

# Combined metrics for comprehensive analysis
pidstat -u -r -d 1

# Install and run iotop
sudo apt install iotop
sudo iotop

# Show only processes performing I/O
sudo iotop -o

# Show accumulated I/O instead of bandwidth
sudo iotop -a

# List all open files
lsof

# Show files opened by specific process
lsof -p PID

# Show processes using specific file
lsof /var/log/syslog

# Show network connections
lsof -i

# Show specific port usage (critical for deployment conflicts)
lsof -i :80
lsof -i :443

# Find processes blocking file deletion
lsof +L1

# Deep dive into container processes
docker top $CONTAINER_ID aux

# Compare container vs host process view
echo "=== Container View ==="
docker exec $CONTAINER_ID ps aux
echo "=== Host View ==="
ps aux | grep $(docker inspect -f '{{.State.Pid}}' $CONTAINER_ID)

# Enter container namespace for detailed management
nsenter -t $(docker inspect -f '{{.State.Pid}}' $CONTAINER_ID) -p -n htop

# Monitor all processes across container boundaries
ps axf -o pid,ppid,cmd | grep -E "(docker|containerd|runc)"

# Comprehensive zombie analysis
ps -eo pid,ppid,state,comm | awk '$3=="Z" {print "Zombie PID:", $1, "Parent:", $2, "Command:", $4}'

# Find and investigate problematic parent processes
for zombie_pid in $(ps -eo pid,state | awk '$2=="Z" {print $1}'); do
    parent_pid=$(ps -o ppid= -p $zombie_pid)
    echo "Zombie $zombie_pid has parent $parent_pid"
    ps -p $parent_pid -o pid,cmd
done

# Automated zombie cleanup for CI/CD
#!/bin/bash
ZOMBIE_COUNT=$(ps aux | awk '$8 ~ /^Z/ { count++ } END { print count+0 }')
if [ $ZOMBIE_COUNT -gt 10 ]; then
    echo "WARNING: $ZOMBIE_COUNT zombie processes detected"
    ps aux | awk '$8 ~ /^Z/ { print $2, $11 }' | \
        logger -t zombie_alert -p daemon.warn
fi

# Identify top CPU consumers
top -o %CPU

# Get detailed CPU breakdown
pidstat -u 1 10

# Check system load average
uptime

# Examine specific process behavior
strace -p PID

# Find CPU-intensive threads within a process
top -H -p PID

# Monitor memory usage over time
pidstat -r 1 | grep PID

# Check detailed memory mappings
cat /proc/PID/smaps

# Monitor memory growth
watch -n 1 'ps -o pid,ppid,cmd,pmem,rss -p PID'

# Use valgrind for development debugging
valgrind --leak-check=full ./your_program

# Identify stuck deployment processes
ps aux | grep -E "(ansible|terraform|kubectl|docker)" | \
awk '$8 ~ /D|Z/ {print "Stuck process:", $11, "State:", $8, "PID:", $2}'

# Check for resource locks
lsof | grep -E "(\.lock|\.pid)" | grep -E "(deploy|build|install)"

# Debug unresponsive containers
docker exec $CONTAINER_ID ps aux | \
awk '$8=="D" {print "Uninterruptible sleep:", $11}'

# Real-time resource contention monitoring
watch -n 2 'ps aux --sort=-%cpu | head -10 && echo "=== Memory ===" && ps aux --sort=-%mem | head -5'

# Network-intensive processes affecting deployment speed
netstat -tulpn | grep ESTABLISHED | awk '{print $7}' | sort | uniq -c | sort -nr

# I/O wait investigation
iostat -x 1 5

#!/bin/bash
# advanced_process_monitor.sh

LOG_FILE="/var/log/process_monitor.log"
THRESHOLD_CPU=80
THRESHOLD_MEM=85

monitor_processes() {
    TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')
    
    # Monitor high CPU usage
    ps aux --sort=-%cpu | head -5 | while read line; do
        CPU=$(echo $line | awk '{print $3}')
        if (( $(echo "$CPU > $THRESHOLD_CPU" | bc -l) )); then
            echo "[$TIMESTAMP] HIGH_CPU: $line" >> $LOG_FILE
        fi
    done
    
    # Monitor high memory usage
    ps aux --sort=-%mem | head -5 | while read line; do
        MEM=$(echo $line | awk '{print $4}')
        if (( $(echo "$MEM > $THRESHOLD_MEM" | bc -l) )); then
            echo "[$TIMESTAMP] HIGH_MEM: $line" >> $LOG_FILE
        fi
    done
}

# Continuous monitoring with adaptive intervals
while true; do
    LOAD=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | sed 's/,//')
    if (( $(echo "$LOAD > 2.0" | bc -l) )); then
        INTERVAL=1
    else
        INTERVAL=5
    fi
    
    monitor_processes
    sleep $INTERVAL
done

#!/bin/bash
# deployment_process_guard.sh
set -e

# Pre-deployment cleanup
echo "Cleaning up previous deployment processes..."
pkill -f "previous_deployment" -TERM 2>/dev/null || true
sleep 5

# Monitor deployment health
monitor_deployment() {
    local deployment_pid=$1
    while kill -0 $deployment_pid 2>/dev/null; do
        # Check for excessive runtime
        if ps -p $deployment_pid -o etime= | grep -q "0[5-9]:[0-9][0-9]"; then
            echo "Deployment taking too long, investigating..."
            ps -p $deployment_pid -o pid,ppid,etime,cmd
            # Log resource usage
            pidstat -p $deployment_pid 1 1
        fi
        sleep 30
    done
}

# Process health check for monitoring integration
check_critical_processes() {
    local critical_procs=("nginx" "postgresql" "redis-server" "prometheus")
    local failed_procs=()
    
    for proc in "${critical_procs[@]}"; do
        if ! pgrep "$proc" > /dev/null; then
            failed_procs+=("$proc")
        fi
    done
    
    if [ ${#failed_procs[@]} -gt 0 ]; then
        echo "CRITICAL: Missing processes: ${failed_procs[*]}"
        exit 2
    fi
    echo "OK: All critical processes running"
}

# Monitor process count changes
watch -n 2 'ps aux | wc -l'

# Monitor memory usage trends
watch -n 1 free -h

# Monitor specific process with highlighting
watch -d -n 1 'ps aux --sort=-%cpu | head -10'

# Container-specific monitoring
watch -n 2 'docker stats --no-stream'

# Pin critical services to specific CPU cores
taskset -cp 0-3 $(pgrep prometheus)
taskset -cp 4-7 $(pgrep grafana-server)

# Verify affinity settings
for pid in $(pgrep nginx); do
    echo "PID $pid affinity: $(taskset -cp $pid)"
done

# Set affinity for new processes
taskset -c 0-3 /usr/bin/critical-service

# Monitor memory pressure and manage processes proactively
free -h && echo "=== Top Memory Consumers ===" && \
ps aux --sort=-%mem | head -10 | \
awk 'NR>1 && $4>10 {print "High memory process:", $11, "(" $4 "% memory)"}'

# Set memory limits for processes (requires systemd)
systemctl set-property your-service.service MemoryLimit=1G

# Use more efficient alternatives to common patterns
# Instead of: ps aux | grep pattern
pgrep -f pattern
pidof process_name

# Batch processing for reduced overhead
top -b -n 1 | head -20
ps aux --no-headers

# Resource-aware monitoring frequency
LOAD=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | sed 's/,//')
if (( $(echo "$LOAD > 2.0" | bc -l) )); then
    INTERVAL=1
else
    INTERVAL=5
fi

#!/bin/bash
# emergency_triage.sh - System stress response

echo "=== EMERGENCY SYSTEM TRIAGE ==="
echo "Timestamp: $(date)"
echo

echo "=== System Load ==="
uptime && free -h
echo

echo "=== Top CPU Consumers ==="
ps aux --sort=-%cpu | head -5
echo

echo "=== Memory Pressure ==="
ps aux --sort=-%mem | head -5
echo

echo "=== Process State Summary ==="
echo "Total processes: $(ps aux | wc -l)"
echo "Zombie processes: $(ps aux | awk '$8=="Z"' | wc -l)"
echo "Uninterruptible sleep: $(ps aux | awk '$8=="D"' | wc -l)"
echo

echo "=== Resource Limits Check ==="
ulimit -a | head -5

# Export process metrics for Prometheus
ps aux | awk 'NR>1 {cpu+=$3; mem+=$4; count++} END {
    print "cpu_usage_total", cpu; 
    print "memory_usage_total", mem; 
    print "process_count", count
}' | curl -X POST http://pushgateway:9091/metrics/job/process_monitor/instance/$(hostname)

# Health check integration
#!/bin/bash
# monitor_health_check.sh

if ! pgrep -f "process_monitor.sh" > /dev/null; then
    echo "WARNING: Process monitor not running"
    systemctl restart process-monitor
fi

if [[ $(find /var/log -name "process_monitor.log*" -mtime +7 | wc -l) -eq 0 ]]; then
    echo "WARNING: Log rotation may not be working"
fi