Linux运维实践(4) 进程管理和系统监控实战

青橙

Mar 14 2026

Linux

linux, ops

学习目标

✅ 掌握进程查看和管理命令
✅ 学会系统资源监控和分析
✅ 掌握计划任务配置
✅ 理解systemd服务管理

第一部分：进程基础

cd ~/linux-learning/day4
mkdir process-management
cd process-management

# 1. 什么是进程？
# 进程是正在运行的程序实例，每个进程都有唯一的PID

# 2. 查看当前Shell的进程
echo "当前Shell的PID: $$"
echo "当前Shell的父进程PID: $PPID"

# 3. 创建一些练习进程（打开多个终端窗口）
# 打开3个新的SSH连接或终端标签页
# 在每个终端运行：
ping baidu.com > /dev/null &
# 或
while true; do echo "running" > /dev/null; sleep 5; done &

第二部分：进程查看命令

1. ps - 进程快照

# 基本用法
ps                     # 查看当前终端的进程
ps aux                 # 查看所有进程（最常用）
ps -ef                 # 查看所有进程（另一种格式）

# 理解ps aux输出
# USER   PID  %CPU %MEM VSZ   RSS   TTY STAT START TIME COMMAND
# 用户  进程号 CPU% 内存% 虚拟内存 物理内存 终端 状态 启动时间 CPU时间 命令

# 常用组合
ps aux | grep nginx    # 查找nginx进程
ps aux --sort=-%cpu    # 按CPU使用率排序
ps aux --sort=-%mem    # 按内存使用率排序
ps -u root             # 查看root用户的进程
ps -p 1                # 查看PID为1的进程（init/systemd）

# 自定义输出格式
ps -eo pid,ppid,cmd,%cpu,%mem --sort=-%cpu | head -10
# 显示：PID,父PID,命令,CPU%,内存%，按CPU降序取前10

# 实战练习
echo "=== 当前系统前5个CPU消耗最大的进程 ==="
ps aux --sort=-%cpu | head -6

echo "=== 当前系统前5个内存消耗最大的进程 ==="
ps aux --sort=-%mem | head -6

2. top - 动态进程监控

# 启动top
top

# top界面解读
# 第1行：当前时间、系统运行时间、登录用户数、负载(1/5/15分钟)
# 第2行：进程总数、运行中、睡眠、停止、僵尸
# 第3行：CPU使用率（us用户、sy系统、ni优先级、id空闲、waIO等待、hi硬件中断、si软件中断、st虚拟化）
# 第4行：内存使用（total总量、free空闲、used已用、buff/cache缓存）
# 第5行：交换分区

# top交互命令（运行时按）
# q：退出
# 1：查看每个CPU核心的使用情况
# m：内存使用显示切换
# P：按CPU使用率排序
# M：按内存使用率排序
# k：杀死进程（会提示输入PID）
# r：修改进程优先级（renice）
# u：查看指定用户的进程
# d：修改刷新间隔（秒）

# 批处理模式
top -b -n 1 > top_snapshot.txt   # 一次性输出到文件
top -b -d 2 -n 5 > top_log.txt   # 每2秒一次，共5次

# 实战：监控特定进程
top -p $(pgrep -d ',' -f "nginx|mysql")   # 监控nginx和mysql

3. 进程树查看

# 安装pstree
dnf install -y psmisc

# 查看进程树
pstree                      # 树形显示进程
pstree -p                   # 显示PID
pstree -u                   # 显示用户切换
pstree -ap                  # 显示所有细节

# 实战：查看SSH服务进程树
pstree -p | grep sshd -A 5 -B 5

# 查看特定进程的父进程
ps -p $$ -o ppid=           # 查看当前Shell的父PID

第三部分：进程控制

1. 进程信号和kill

# 查看所有信号
kill -l

# 常用信号
# 1：HUP（挂起，重新加载配置）
# 2：INT（中断，Ctrl+C）
# 9：KILL（强制终止，无法捕获）
# 15：TERM（正常终止，默认）
# 18：CONT（继续）
# 19：STOP（暂停）

# 创建测试进程
cat > test_process.sh << 'EOF'
#!/bin/bash
echo "测试进程启动，PID: $$"
count=0
while true; do
    echo "运行中... $count"
    ((count++))
    sleep 2
done
EOF
chmod +x test_process.sh
./test_process.sh &
TEST_PID=$!
echo "测试进程PID: $TEST_PID"

# 进程控制练习
kill -15 $TEST_PID          # 正常终止
kill -9 $TEST_PID           # 强制终止（如果-15无效）
kill -19 $TEST_PID          # 暂停进程
kill -18 $TEST_PID          # 继续暂停的进程
kill -1 $TEST_PID           # 重新加载配置（如果程序支持）

# 批量操作
pkill -f "test_process"     # 按名称杀死进程
killall test_process.sh     # 杀死所有同名进程

# 实战：重启nginx
# 正常重启
kill -HUP $(cat /var/run/nginx.pid)
# 或者
nginx -s reload

2. 进程优先级（nice）

# 查看进程优先级
ps -eo pid,pri,nice,cmd | head -10

# nice值范围：-20（最高优先级）到19（最低优先级）
# 普通用户只能调高nice值（降低优先级）

# 启动时设置优先级
nice -n 10 ./test_process.sh &     # 以较低优先级运行

# 修改运行中进程的优先级
renice -n 5 -p $TEST_PID           # 将nice值改为5
renice -n -5 -p $TEST_PID          # 需要root权限才能降低nice值

# 实战：CPU密集型任务测试
cat > cpu_test.sh << 'EOF'
#!/bin/bash
echo "CPU测试开始 - PID: $$"
for i in {1..10000}; do
    echo "scale=5000; 4*a(1)" | bc -l > /dev/null
done
echo "测试完成"
EOF
chmod +x cpu_test.sh

# 同时运行两个测试，观察优先级的影响
./cpu_test.sh &
./cpu_test.sh &
renice -n 10 $(pgrep -f cpu_test.sh | head -1)
top -p $(pgrep -f cpu_test.sh | tr '\n' ',' | sed 's/,$//')

第四部分：系统资源监控

1. 内存监控

# free命令
free -h                 # 人性化显示
free -m                 # 以MB显示
free -s 2               # 每2秒刷新一次

# 查看内存详细信息
cat /proc/meminfo | head -10

# 实战：内存监控脚本
cat > memory_monitor.sh << 'EOF'
#!/bin/bash
# 内存监控脚本，超过阈值告警

THRESHOLD=90
LOG_FILE="memory_alert.log"

while true; do
    MEM_USAGE=$(free | grep Mem | awk '{print ($3/$2)*100}')
    MEM_USAGE_INT=$(printf "%.0f" $MEM_USAGE)

    if [ $MEM_USAGE_INT -gt $THRESHOLD ]; then
        echo "$(date): 警告！内存使用率: $MEM_USAGE%" >> $LOG_FILE
        echo "Top 5内存进程:" >> $LOG_FILE
        ps aux --sort=-%mem | head -6 >> $LOG_FILE
        echo "---" >> $LOG_FILE
    fi

    echo "$(date): 当前内存使用: $MEM_USAGE%"
    sleep 10
done
EOF
chmod +x memory_monitor.sh
# ./memory_monitor.sh &  # 后台运行监控

2. CPU监控

# mpstat（需要安装sysstat）
dnf install -y sysstat
mpstat 2 5              # 每2秒一次，共5次

# 查看CPU信息
cat /proc/cpuinfo | grep "model name" | head -1
nproc                    # CPU核心数

# 负载监控
uptime                   # 查看系统负载
cat /proc/loadavg       # 查看平均负载

# 实战：CPU压力测试
# 安装压力测试工具
dnf install -y epel-release && dnf install stress -y

# 进行压力测试
stress --cpu 4 --timeout 60 &
# 在另一个终端观察
top -b -n 5 -d 1 | grep "Cpu"

3. 磁盘IO监控

# iostat
iostat -x 2 5            # 扩展统计，每2秒一次

# 解释输出：
# rrqm/s: 每秒合并读请求
# wrqm/s: 每秒合并写请求
# r/s:    每秒读次数
# w/s:    每秒写次数
# rkB/s:  每秒读KB
# wkB/s:  每秒写KB
# await:  IO平均等待时间（毫秒）
# util:   磁盘利用率

# iotop（需要安装）
dnf install -y iotop
iotop -o                 # 只显示有IO的进程

# 实战：模拟IO负载
dd if=/dev/zero of=testfile bs=1M count=1000 &
iotop -b -n 5 > iotop.log

4. 网络监控

# netstat/ss
netstat -tuln            # 查看监听端口
ss -tuln                 # 更快的替代命令

# 查看网络连接
netstat -an | grep ESTABLISHED | wc -l  # 建立连接数
ss -s                    # 连接统计

# 实时网络流量
dnf install -y nload
nload eth0               # 监控网络流量

# 或者使用
watch -n 1 'netstat -i'  # 每秒刷新网络接口统计

第五部分：计划任务

1. crontab - 定时任务

# crontab格式
# * * * * * command
# ┬ ┬ ┬ ┬ ┬
# │ │ │ │ │
# │ │ │ │ └─ 星期 (0-7, 0和7都是周日)
# │ │ │ └─── 月份 (1-12)
# │ │ └───── 日期 (1-31)
# │ └─────── 小时 (0-23)
# └───────── 分钟 (0-59)

# 常用示例
# */5 * * * *    每5分钟
# 0 * * * *      每小时
# 0 2 * * *      每天凌晨2点
# 0 9-17 * * 1-5 工作日9-17点每小时

# 编辑当前用户crontab
crontab -e

# 添加一些练习任务
# 每分钟记录时间
* * * * * echo "$(date): 计划任务运行中" >> ~/cron_test.log

# 每天凌晨备份
0 2 * * * tar -czf /backup/home_$(date +\%Y\%m\%d).tar.gz /home/

# 每周一清理日志
0 3 * * 1 find /var/log -name "*.log" -mtime +7 -delete

# 查看crontab
crontab -l

# 实战：创建系统监控计划任务
cat > /home/$USER/system_monitor.sh << 'EOF'
#!/bin/bash
# 系统监控脚本，每5分钟执行一次

LOG_DIR="/var/log/system_monitor"
mkdir -p $LOG_DIR

TIMESTAMP=$(date +%Y%m%d_%H%M%S)
REPORT="$LOG_DIR/report_$TIMESTAMP.log"

{
    echo "=== 系统监控报告 $TIMESTAMP ==="
    echo "负载: $(uptime)"
    echo "内存: $(free -h)"
    echo "磁盘: $(df -h /)"
    echo "Top CPU进程:"
    ps aux --sort=-%cpu | head -5
    echo "连接数: $(ss -s | grep "estab")"
} >> $REPORT

# 清理7天前的报告
find $LOG_DIR -name "report_*.log" -mtime +7 -delete
EOF

chmod +x /home/$USER/system_monitor.sh

# 添加到crontab
(crontab -l 2>/dev/null; echo "*/5 * * * * /home/$USER/system_monitor.sh") | crontab -

2. systemd定时器

# 创建systemd service和timer
# 服务单元
sudo cat > /etc/systemd/system/monitor.service << 'EOF'
[Unit]
Description=System Monitor Service

[Service]
Type=oneshot
ExecStart=/home/你的用户名/system_monitor.sh
User=你的用户名
EOF

# 定时器单元
sudo cat > /etc/systemd/system/monitor.timer << 'EOF'
[Unit]
Description=Run monitor every hour

[Timer]
OnCalendar=hourly
Persistent=true

[Install]
WantedBy=timers.target
EOF

# 启用定时器
sudo systemctl daemon-reload
sudo systemctl enable monitor.timer
sudo systemctl start monitor.timer
systemctl list-timers

第六部分：systemd服务管理

1. 服务基本操作

# 查看服务状态
systemctl status sshd
systemctl status nginx    # 如果没安装会提示

# 服务管理
systemctl start nginx     # 启动服务
systemctl stop nginx      # 停止服务
systemctl restart nginx   # 重启服务
systemctl reload nginx    # 重新加载配置
systemctl enable nginx    # 开机自启
systemctl disable nginx   # 禁用开机自启
systemctl is-active sshd  # 检查是否运行
systemctl is-enabled sshd # 检查是否开机启动

# 查看所有服务
systemctl list-units --type=service --all
systemctl list-units --type=service --state=running

2. 创建自定义服务

# 创建一个简单的Web服务脚本
cat > /home/$USER/myweb.sh << 'EOF'
#!/bin/bash
# 简单的HTTP服务器
while true; do
    echo -e "HTTP/1.1 200 OK\n\nHello World" | nc -l -p 8080 -q 1
done
EOF
chmod +x /home/$USER/myweb.sh

# 创建服务单元
sudo cat > /etc/systemd/system/myweb.service << 'EOF'
[Unit]
Description=My Simple Web Server
After=network.target

[Service]
Type=simple
User=你的用户名
ExecStart=/home/你的用户名/myweb.sh
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target
EOF

# 启动服务
sudo systemctl daemon-reload
sudo systemctl start myweb
sudo systemctl enable myweb
sudo systemctl status myweb

# 测试服务
curl http://localhost:8080

第七部分：综合实战 - 系统监控平台

现在我们把今天学的知识组合起来，创建一个简单的系统监控平台：

cd ~/linux-learning/day4
mkdir monitoring-platform
cd monitoring-platform

# 1. 创建监控脚本集合
cat > monitor_collector.sh << 'EOF'
#!/bin/bash
# 系统监控数据收集器

CONFIG_DIR="$HOME/linux-learning/day4/monitoring-platform"
DATA_DIR="$CONFIG_DIR/data"
mkdir -p $DATA_DIR

# 收集函数
collect_cpu() {
    echo "=== CPU信息 ===" > $DATA_DIR/cpu.txt
    top -bn1 | head -3 >> $DATA_DIR/cpu.txt
    echo "CPU使用率TOP5:" >> $DATA_DIR/cpu.txt
    ps aux --sort=-%cpu | head -6 >> $DATA_DIR/cpu.txt
}

collect_memory() {
    echo "=== 内存信息 ===" > $DATA_DIR/memory.txt
    free -h >> $DATA_DIR/memory.txt
    echo >> $DATA_DIR/memory.txt
    echo "内存使用TOP5:" >> $DATA_DIR/memory.txt
    ps aux --sort=-%mem | head -6 >> $DATA_DIR/memory.txt
}

collect_disk() {
    echo "=== 磁盘信息 ===" > $DATA_DIR/disk.txt
    df -h >> $DATA_DIR/disk.txt
    echo >> $DATA_DIR/disk.txt
    echo "IO统计:" >> $DATA_DIR/disk.txt
    iostat -x 1 1 | grep -v "^$" >> $DATA_DIR/disk.txt
}

collect_network() {
    echo "=== 网络信息 ===" > $DATA_DIR/network.txt
    echo "连接数统计:" >> $DATA_DIR/network.txt
    ss -s >> $DATA_DIR/network.txt
    echo >> $DATA_DIR/network.txt
    echo "监听端口:" >> $DATA_DIR/network.txt
    ss -tuln >> $DATA_DIR/network.txt
}

collect_process() {
    echo "=== 进程信息 ===" > $DATA_DIR/process.txt
    echo "总进程数: $(ps aux | wc -l)" >> $DATA_DIR/process.txt
    echo "僵尸进程: $(ps aux | grep 'Z' | wc -l)" >> $DATA_DIR/process.txt
    echo >> $DATA_DIR/process.txt
    echo "systemd进程树:" >> $DATA_DIR/process.txt
    pstree -p | grep systemd -A 5 >> $DATA_DIR/process.txt
}

# 生成HTML报告
generate_html() {
    HTML_FILE="$DATA_DIR/report_$(date +%Y%m%d_%H%M%S).html"

    cat > $HTML_FILE << HTMLHEAD
<!DOCTYPE html>
<html>
<head>
    <title>系统监控报告</title>
    <style>
        body { font-family: Arial; margin: 20px; }
        h1 { color: #333; }
        h2 { color: #666; border-bottom: 1px solid #ccc; }
        pre { background: #f5f5f5; padding: 10px; border-radius: 5px; }
        .warning { color: red; }
        .normal { color: green; }
    </style>
</head>
<body>
    <h1>系统监控报告 - $(date)</h1>
HTMLHEAD

    # 添加各模块
    for section in cpu memory disk network process; do
        echo "<h2>${section^^} 信息</h2>" >> $HTML_FILE
        echo "<pre>" >> $HTML_FILE
        cat $DATA_DIR/$section.txt >> $HTML_FILE
        echo "</pre>" >> $HTML_FILE
    done

    echo "</body></html>" >> $HTML_FILE

    echo "HTML报告已生成: $HTML_FILE"
}

# 主函数
main() {
    echo "开始收集系统信息..."
    collect_cpu
    collect_memory
    collect_disk
    collect_network
    collect_process
    generate_html
    echo "收集完成！"
}

main
EOF

chmod +x monitor_collector.sh

# 2. 创建告警检查脚本
cat > alert_checker.sh << 'EOF'
#!/bin/bash
# 告警检查脚本

# 阈值设置
CPU_THRESHOLD=80
MEM_THRESHOLD=90
DISK_THRESHOLD=85

ALERT_LOG="alerts.log"

check_cpu() {
    CPU_USAGE=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1)
    CPU_USAGE_INT=${CPU_USAGE%.*}
    if [ $CPU_USAGE_INT -gt $CPU_THRESHOLD ]; then
        echo "$(date): CPU告警 - 使用率 $CPU_USAGE%" >> $ALERT_LOG
        return 1
    fi
    return 0
}

check_memory() {
    MEM_USAGE=$(free | grep Mem | awk '{print ($3/$2)*100}')
    MEM_USAGE_INT=${MEM_USAGE%.*}
    if [ $MEM_USAGE_INT -gt $MEM_THRESHOLD ]; then
        echo "$(date): 内存告警 - 使用率 $MEM_USAGE%" >> $ALERT_LOG
        return 1
    fi
    return 0
}

check_disk() {
    DISK_USAGE=$(df / | tail -1 | awk '{print $5}' | sed 's/%//')
    if [ $DISK_USAGE -gt $DISK_THRESHOLD ]; then
        echo "$(date): 磁盘告警 - 使用率 $DISK_USAGE%" >> $ALERT_LOG
        return 1
    fi
    return 0
}

check_process() {
    ZOMBIE_COUNT=$(ps aux | grep 'Z' | wc -l)
    if [ $ZOMBIE_COUNT -gt 5 ]; then
        echo "$(date): 进程告警 - 僵尸进程数 $ZOMBIE_COUNT" >> $ALERT_LOG
        return 1
    fi
    return 0
}

# 执行检查
echo "=== 开始检查 $(date) ==="
check_cpu
check_memory
check_disk
check_process

if [ -s $ALERT_LOG ]; then
    echo "⚠️  发现告警，请查看 $ALERT_LOG"
    tail -5 $ALERT_LOG
else
    echo "✅ 所有检查正常"
fi
EOF

chmod +x alert_checker.sh

# 3. 设置定时监控
(crontab -l 2>/dev/null; echo "*/10 * * * * $PWD/monitor_collector.sh") | crontab -
(crontab -l 2>/dev/null; echo "*/5 * * * * $PWD/alert_checker.sh") | crontab -

# 立即运行一次
./monitor_collector.sh
./alert_checker.sh

# 查看生成的数据
ls -la data/

第八部分：今日挑战任务

# 挑战1：找出消耗CPU最多的进程，并降低其优先级
# 找出CPU使用率超过50%的进程
ps aux --sort=-%cpu | awk '$3 > 50 {print $2}' | while read pid; do
    echo "降低进程 $pid 的优先级"
    renice -n 10 -p $pid
done

# 挑战2：创建自动清理脚本
# 编写脚本，删除30天前的日志，但保留每月1号的日志
cat > cleanup_logs.sh << 'EOF'
#!/bin/bash
LOG_DIR="/var/log"
KEEP_PATTERN="*-??????01"  # 每月1号的日志

find $LOG_DIR -name "*.log" -type f -mtime +30 ! -name "$KEEP_PATTERN" -delete
find $LOG_DIR -name "*.log.*" -type f -mtime +30 ! -name "$KEEP_PATTERN" -delete

echo "$(date): 清理完成" >> /var/log/cleanup.log
EOF

# 挑战3：进程监控脚本
# 监控特定进程，如果进程挂了自动重启
cat > process_watchdog.sh << 'EOF'
#!/bin/bash
PROCESS_NAME="nginx"
CHECK_INTERVAL=10

while true; do
    if ! pgrep -x "$PROCESS_NAME" > /dev/null; then
        echo "$(date): $PROCESS_NAME 未运行，正在启动..."
        systemctl start $PROCESS_NAME
        echo "$(date): 已启动 $PROCESS_NAME" >> watchdog.log
    fi
    sleep $CHECK_INTERVAL
done
EOF

# 挑战4：系统负载统计
# 每小时统计一次系统负载，生成日报表
cat > load_stat.sh << 'EOF'
#!/bin/bash
STATS_DIR="/var/log/loadstats"
mkdir -p $STATS_DIR

HOUR=$(date +%H)
LOAD=$(uptime | awk -F'load average:' '{print $2}')

echo "$(date +%Y-%m-%d_%H:%M) $LOAD" >> $STATS_DIR/load_$(date +%Y%m%d).log

# 每天0点生成日报
if [ "$HOUR" = "00" ]; then
    YESTERDAY=$(date -d "yesterday" +%Y%m%d)
    REPORT="$STATS_DIR/report_$YESTERDAY.txt"

    echo "=== 昨日负载报告 $YESTERDAY ===" > $REPORT
    echo "最大负载: $(sort -k5 -rn $STATS_DIR/load_$YESTERDAY.log | head -1)" >> $REPORT
    echo "最小负载: $(sort -k5 -n $STATS_DIR/load_$YESTERDAY.log | head -1)" >> $REPORT
    echo "平均负载: $(awk '{sum+=$5} END {print sum/NR}' $STATS_DIR/load_$YESTERDAY.log)" >> $REPORT
fi
EOF

第九部分：面试题精选

# 1. 如何查看系统负载？负载高怎么排查？
答：uptime, top, w
    排查：top看CPU进程，iostat看IO，netstat看网络

# 2. 如何查看哪个进程占用端口80？
答：lsof -i:80 或 netstat -tulnp | grep :80

# 3. 如何让脚本在后台运行，退出终端后继续运行？
答：nohup script.sh & 或 使用screen/tmux

# 4. 僵尸进程是什么？怎么处理？
答：子进程结束但父进程没有回收，状态为Z
    处理：kill父进程，让init回收

# 5. 如何限制进程的CPU使用率？
答：使用cpulimit工具，或cgroups

# 6. crontab中的%需要转义吗？
答：需要，用\%表示

# 7. systemctl和service命令的区别？
答：systemctl是新版systemd的命令，service是旧版SysVinit

第十部分：今日总结

今天你掌握了：

✅ 进程查看：ps, top, pstree
✅ 进程控制：kill, nice, renice
✅ 资源监控：free, iostat, mpstat
✅ 计划任务：crontab, systemd timer
✅ 服务管理：systemctl

实战经验：

创建了系统监控平台
实现了自动告警
配置了定时任务
管理了系统服务

今日名言：”进程是Linux的心脏，监控是运维的眼睛。”