08-操作系统与Linux

┌─────────────────────────────┐
│        内核空间               │  （操作系统使用，不可访问）
├─────────────────────────────┤
│        栈 (Stack)            │  每个线程独立，存储局部变量
├─────────────────────────────┤
│        内存映射区             │  mmap 映射的文件
├─────────────────────────────┤
│        堆 (Heap)             │  动态分配的内存（malloc/new）
├─────────────────────────────┤
│        未初始化数据 (.bss)    │  未初始化的全局变量
├─────────────────────────────┤
│        已初始化数据 (.data)   │  已初始化的全局变量
├─────────────────────────────┤
│        只读数据 (.rodata)    │  常量字符串
├─────────────────────────────┤
│        代码段 (.text)        │  程序机器码
└─────────────────────────────┘

# 查看进程
ps aux                  # 查看所有进程
ps -ef                  # 查看所有进程（详细）
top                     # 实时查看进程
pgrep -l "java"         # 按名称查找进程

# 查看线程
ps -T -p <PID>          # 查看进程的所有线程
top -H -p <PID>         # 实时查看线程
pidstat -t -p <PID> 1   # 每秒查看线程统计

# Java 中创建线程
// 方式1：继承 Thread
public class MyThread extends Thread {
    public void run() {
        System.out.println("Thread running");
    }
}
new MyThread().start();

// 方式2：实现 Runnable
Thread t = new Thread(() -> System.out.println("Thread running"));
t.start();

// 查看 Java 进程的线程
jstack <PID>            # 打印所有线程栈
jcmd <PID> Thread.print # 打印线程信息

进程 A ──写入──→ 管道缓冲区 ──读取──→ 进程 B

mkfifo /tmp/my_fifo
进程 A ──写入──→ /tmp/my_fifo ──读取──→ 进程 B

进程 A ──发送消息──→ 消息队列（内核链表） ──接收消息──→ 进程 B

物理内存
├── 进程 A 的地址空间 ←── 映射 ──→ 共享内存段
└── 进程 B 的地址空间 ←── 映射 ──→ 共享内存段

进程 A ──sem_wait──→ 信号量 ──sem_post──→ 进程 B

进程 A ──TCP/UDP──→ 内核协议栈 ──网络──→ 进程 B（可能在另一台主机）

# 管道示例
# 创建管道并使用
mkfifo /tmp/pipe_demo
# 终端1: 写入
echo "hello" > /tmp/pipe_demo
# 终端2: 读取
cat < /tmp/pipe_demo

# 查看 IPC 资源
ipcs -m   # 查看共享内存
ipcs -q   # 查看消息队列
ipcs -s   # 查看信号量

# 删除 IPC 资源
ipcrm -m <SHM_ID>  # 删除共享内存
ipcrm -q <MSG_ID>  # 删除消息队列

// 管道使用示例（C）
#include <unistd.h>
int main() {
    int fd[2];  // fd[0] 读端, fd[1] 写端
    pipe(fd);

    pid_t pid = fork();
    if (pid == 0) {
        // 子进程：写入
        close(fd[0]);
        write(fd[1], "hello", 5);
    } else {
        // 父进程：读取
        close(fd[1]);
        char buf[6];
        read(fd[0], buf, 5);
        buf[5] = '\0';
        printf("%s\n", buf);
    }
}

// 共享内存使用示例（C）
#include <sys/shm.h>
int main() {
    int shmid = shmget(IPC_PRIVATE, 1024, IPC_CREAT);
    char* addr = shmat(shmid, NULL, 0);

    // 写入数据
    strcpy(addr, "shared memory");

    // 分离
    shmdt(addr);
    // ... 另一个进程读取 ...
    shmctl(shmid, IPC_RMID, NULL);
}

线程 A ──lock()──→ 获取锁 ──访问共享资源──→ unlock()
线程 B ──lock()──→ 阻塞等待 ←──────────────────→ 被唤醒获取锁

生产者：                                      消费者：
  lock()                                        lock()
  while (buffer.full) {                         while (buffer.empty) {
    wait()  ←─ 释放锁，进入等待队列                wait() ←─ 释放锁，进入等待队列
  }                                              }
  produce()                                     consume()
  signal()  ──→ 唤醒一个等待线程                  signal() ──→ 唤醒一个等待线程
  unlock()                                      unlock()

信号量 S = N（可用资源数）

线程 A ──wait(S)──→ S > 0? S--, 继续 : 阻塞
线程 A ──post(S)──→ S++, 唤醒一个等待线程

Barrier B = 3（需 3 个线程到达）

线程 1 ──到达屏障──→ 阻塞
线程 2 ──到达屏障──→ 阻塞
线程 3 ──到达屏障──→ 全部唤醒，继续执行

// Java 线程间通信示例

// 1. synchronized + wait/notify（生产者-消费者）
class Buffer {
    private int value;
    private boolean empty = true;

    public synchronized void produce(int v) throws InterruptedException {
        while (!empty) { wait(); }  // 等待消费者消费
        value = v;
        empty = false;
        notifyAll();  // 通知消费者
    }

    public synchronized int consume() throws InterruptedException {
        while (empty) { wait(); }  // 等待生产者生产
        empty = true;
        notifyAll();  // 通知生产者
        return value;
    }
}

// 2. Lock + Condition
ReentrantLock lock = new ReentrantLock();
Condition notFull = lock.newCondition();
Condition notEmpty = lock.newCondition();

// 3. Semaphore（限流）
Semaphore sem = new Semaphore(3);  // 最多 3 个线程并发
sem.acquire();
// 访问共享资源
sem.release();

// 4. CountDownLatch（倒计时锁存）
CountDownLatch latch = new CountDownLatch(3);
// 线程完成任务
latch.countDown();
// 等待所有线程完成
latch.await();

// 5. CyclicBarrier（循环屏障）
CyclicBarrier barrier = new CyclicBarrier(3);
// 所有线程同步到达
barrier.await();

// 6. volatile（可见性）
private volatile boolean running = true;

1. 触发切换（时间片用完 / 系统调用 / 中断）
2. 保存当前进程状态：
   - 保存所有 CPU 寄存器到 PCB（进程控制块）
   - 保存程序计数器、栈指针
   - 切换页表（更新 CR3 寄存器）
3. 刷新 TLB（转译后备缓冲器）
4. 刷新 CPU 缓存
5. 恢复目标进程状态：
   - 从目标 PCB 恢复 CPU 寄存器
   - 加载目标页表到 MMU
   - 设置新的程序计数器
6. CPU 开始执行新进程

1. 触发切换（同进程内的线程调度）
2. 保存当前线程状态：
   - 保存 CPU 寄存器到 TCB（线程控制块）
   - 保存栈指针
3. 不需要切换页表（共享地址空间）
4. 不需要刷新 TLB
5. 恢复目标线程状态：
   - 从目标 TCB 恢复 CPU 寄存器
   - 设置新的栈指针
6. CPU 开始执行新线程

# 查看上下文切换统计
vmstat 1          # 每秒查看
# cs 列表示上下文切换次数

# 查看具体进程/线程的上下文切换
pidstat -w -p <PID> 1    # 进程上下文切换
pidstat -t -p <PID> 1    # 线程上下文切换

# 查看系统上下文切换
cat /proc/stat
# context_switch 字段

# 使用 perf 分析上下文切换
perf record -e context-switches -a sleep 10
perf report

# 减少上下文切换的方法
# 1. 减少线程数量
# 2. 使用协程（Java 21 虚拟线程、Go goroutine）
# 3. 绑定 CPU 亲和性（taskset）
taskset -c 0-3 ./my_program  # 绑定到特定 CPU 核心

父进程内存空间                     子进程内存空间（fork 后）
┌──────────────────┐              ┌──────────────────┐
│ 代码段 (只读)     │──共享──→     │ 代码段 (只读)     │
│──────────────────│              │──────────────────│
│ 数据段           │──共享──→     │ 数据段 (只读映射) │
│──────────────────│              │──────────────────│
│ 堆               │──共享──→     │ 堆 (只读映射)     │
│──────────────────│              │──────────────────│
│ 栈               │──共享──→     │ 栈 (只读映射)     │
└──────────────────┘              └──────────────────┘

当子进程尝试写入数据段/堆/栈时：
  → CPU 触发页错误（Page Fault）
  → 内核分配新物理页
  → 复制原页内容到新页
  → 更新子进程页表指向新页
  → 设置页表项为可写
  → 继续执行写操作

# 查看进程内存映射
cat /proc/<PID>/maps

# 查看物理页共享情况
cat /proc/<PID>/smaps

# Linux fork() 使用示例
#include <unistd.h>
#include <stdio.h>

int main() {
    int x = 42;
    pid_t pid = fork();

    if (pid == 0) {
        // 子进程
        printf("Before write: x=%d\n", x);
        x = 100;  // 触发 COW
        printf("After write: x=%d\n", x);
    } else {
        // 父进程
        wait(NULL);
        printf("Parent x=%d\n", x);  // x 仍为 42
    }
    return 0;
}

// Java 中 fork 的间接使用
// JVM 在创建子进程时使用 COW
// 如 Runtime.exec()、ProcessBuilder
ProcessBuilder pb = new ProcessBuilder("cmd");
Process p = pb.start();  // 底层使用 fork + exec

Windows:
  CreateProcess() → 完整复制进程空间 → 开销大（毫秒级）

Linux:
  fork() → 复制页表（COW）→ 开销小（微秒级）
  clone() → 按位共享 → 创建线程

Windows (ACL):
  对象安全描述符 (SID + ACL + DACL)
  - 每个对象有所有者 SID
  - 自由访问控制列表 (DACL)
  - 系统访问控制列表 (SACL)

Linux (UGO + ACL):
  UGO: User(所有者) Group(组) Other(其他)
       rwx  rwx  rwx
  ACL: setfacl/getfacl 扩展权限

# Windows 常用命令
tasklist /FI "IMAGENAME eq java.exe"    # 查看进程
taskkill /PID 1234 /F                   # 强制杀进程
netstat -ano                            # 网络状态
icacls file.txt                         # 查看文件权限

# Linux 常用命令
ps aux | grep java                      # 查看进程
kill -9 1234                            # 强制杀进程
ss -tlnp                                # 网络状态
ls -la file.txt                         # 查看文件权限

┌─────────────────────────────────────────┐
│              用户空间 (Ring 3)            │
│  应用程序 / Shell / 库 (glibc)            │
├─────────────────────────────────────────┤
│              系统调用接口                 │
│  sys_read / sys_write / sys_fork ...     │
├─────────────────────────────────────────┤
│              内核空间 (Ring 0)            │
│  ┌─────────────────────────────────┐    │
│  │       进程调度 (CFS)             │    │
│  ├─────────────────────────────────┤    │
│  │       内存管理                    │    │
│  ├─────────────────────────────────┤    │
│  │       文件系统 (VFS + ext4)       │    │
│  ├─────────────────────────────────┤    │
│  │       设备驱动 (LKM)             │    │
│  ├─────────────────────────────────┤    │
│  │       网络子系统                  │    │
│  ├─────────────────────────────────┤    │
│  │       安全 (SELinux/AppArmor)     │    │
│  └─────────────────────────────────┘    │
├─────────────────────────────────────────┤
│              硬件 (CPU/内存/磁盘/网卡)     │
└─────────────────────────────────────────┘

CFS (Completely Fair Scheduler):
  - 基于红黑树管理进程
  - vruntime = 实际运行时间 / 权重
  - 调度 vruntime 最小的进程
  - 时间片 = 调度周期 / 进程数

虚拟地址空间：
  ├── 内核空间（1GB，x86；或按比例，x86_64）
  └── 用户空间（3GB，x86；或 128TB，x86_64）

内存管理机制：
  - 页式管理（4KB 页 / 2MB 大页）
  - 页表（三级/四级页表）
  - TLB 缓存
  - LRU 页面置换
  - OOM Killer（内存不足时杀进程）

VFS (Virtual File System) 层：
  ├── 抽象的文件操作接口（open/read/write）
  ├── 超级块（Superblock）：文件系统信息
  ├── inode：文件元数据
  └── dentry：目录项缓存

具体实现：
  ├── ext4：默认日志文件系统
  ├── xfs：高性能，适合大文件
  ├── btrfs：支持写时复制、快照
  └── tmpfs：内存文件系统

用户态 → 内核态切换：
  1. 应用程序调用 C 库函数（如 read）
  2. C 库函数触发系统调用（int 0x80 / syscall 指令）
  3. CPU 切换到内核态（Ring 0）
  4. 内核系统调用处理程序执行
  5. 返回用户态

# 查看内核版本
uname -r
uname -a

# 查看内核配置
zcat /proc/config.gz | grep CONFIG_
# 或
cat /boot/config-$(uname -r) | grep CONFIG_

# 查看内核模块
lsmod                    # 列出已加载模块
modprobe <module_name>   # 加载模块
modprobe -r <module_name> # 卸载模块
modinfo <module_name>    # 查看模块信息

# 查看内核参数
sysctl -a                # 列出所有参数
sysctl net.ipv4.ip_forward  # 查看指定参数

# 调整内核参数
sysctl -w net.ipv4.ip_forward=1
# 永久生效：编辑 /etc/sysctl.conf

# 查看内核日志
dmesg
journalctl -k

ps aux          # 显示所有用户的所有进程（BSD 风格）
ps -ef          # 显示所有进程（System V 风格）
ps -o pid,user,%cpu,%mem,cmd  # 自定义输出列
ps -p <PID>     # 查看指定 PID 的进程
ps -u <USER>    # 查看指定用户的进程
ps --sort=-%cpu # 按 CPU 占用排序
ps -efL         # 查看线程信息

USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.1 169448 13200 ?        Ss   Mar01   0:15 /sbin/init
root       100  0.5  2.3 456789 23456 ?        Sl   Mar01  1:23 /usr/sbin/nginx
www-data  200 15.3  5.1 890123 51234 ?        R    10:00   5:34 java -jar app.jar

top                    # 启动 top
top -d 1               # 每秒刷新
top -u <USER>          # 查看指定用户进程
top -p <PID1>,<PID2>   # 查看指定 PID
top -o %CPU            # 按 CPU 占用排序
top -o %MEM            # 按内存占用排序

# top 交互操作
# P: 按 CPU 排序
# M: 按内存排序
# T: 按时间排序
# k: 杀进程
# r: 调整优先级（renice）
# q: 退出

pstree                 # 显示所有进程树
pstree -p              # 显示进程 ID
pstree -u              # 显示用户
pstree -a              # 显示命令行参数
pstree <PID>           # 显示指定进程的子树

pgrep -l "java"        # 按名称查找进程（列出 PID 和名称）
pgrep -a "nginx"       # 按完整命令行查找
pidof nginx            # 查找 nginx 的 PID
ls /proc/<PID>/        # 查看进程的详细信息
cat /proc/<PID>/status # 查看进程状态
cat /proc/<PID>/cmdline # 查看命令行参数

# 查找占用 CPU 最高的 5 个进程
ps aux --sort=-%cpu | head -6

# 查看 Java 进程的线程
ps -T -p $(pgrep -f "java" | head -1) | head -20

# 查找僵尸进程
ps aux | grep defunct

# 实时监控特定进程
top -d 1 -p $(pgrep -f "myapp")

# 查看所有日志
journalctl

# 查看最近 100 行
journalctl -n 100

# 查看最新日志并实时跟踪（类似 tail -f）
journalctl -f

# 查看今天的日志
journalctl --today

# 查看指定时间范围
journalctl --since "2024-01-01" --until "2024-01-02"

# 查看指定服务的日志
journalctl -u nginx.service
journalctl -u nginx.service -f  # 实时跟踪

# 查看指定优先级的日志
journalctl -p err     # 错误
journalctl -p crit    # 严重
journalctl -p alert   # 警报

# 查看内核日志
journalctl -k

# 查看指定用户的日志
journalctl _UID=1000

# 查看指定 PID 的日志
journalctl _PID=1234

# 导出日志
journalctl --no-pager > logs.txt

# 系统日志
cat /var/log/messages          # 通用系统日志
tail -f /var/log/messages      # 实时查看

# 认证日志
cat /var/log/auth.log          # 登录、sudo 等认证日志（Debian/Ubuntu）
cat /var/log/secure            # 认证日志（RHEL/CentOS）

# 内核日志
dmesg                          # 查看内核日志
dmesg | tail -50               # 查看最近 50 行
dmesg -T                       # 带时间戳
dmesg -w                       # 实时跟踪

# 启动日志
cat /var/log/boot.log          # 启动过程日志

# 应用日志
ls /var/log/nginx/             # Nginx 日志
ls /var/log/mysql/             # MySQL 日志

# 组合使用 grep 过滤日志
grep -i "error" /var/log/messages | tail -20
grep "Failed password" /var/log/auth.log  # 查找失败登录
grep -i "oom\|killed" /var/log/syslog     # 查找 OOM 事件

# 使用 journalctl 过滤
journalctl -p err -u myapp.service --since "10 minutes ago"

# 查看登录历史
last                           # 登录成功历史
lastb                          # 登录失败历史
w                              # 当前登录用户
who                            # 当前登录用户（详细）

# 查看系统启动时间
uptime                         # 系统运行时长
who -b                         # 最后启动时间

Shell 变量 vs 环境变量：

Shell 变量：
  myvar="hello"     # 仅当前 Shell 可见
  echo $myvar       # 输出：hello
  bash -c 'echo $myvar'  # 输出：（空，子 shell 看不到）

环境变量（export）：
  export myvar="hello"  # 导出为环境变量
  echo $myvar           # 输出：hello
  bash -c 'echo $myvar' # 输出：hello（子 shell 可见）

当前 Shell
  ├── export VAR=value
  │   VAR 加入 Shell 的环境变量列表
  │
  └── 启动子进程（bash、java、python 等）
      ├── Shell 通过 execve() 系统调用传递环境变量
      ├── 子进程继承环境变量
      └── 子进程通过 getenv("VAR") 访问

# 设置环境变量（临时，仅当前会话）
export JAVA_HOME=/usr/lib/jvm/java-17
export PATH=$JAVA_HOME/bin:$PATH
export LANG=en_US.UTF-8

# 查看环境变量
env                              # 所有环境变量
printenv                        # 所有环境变量
echo $JAVA_HOME                 # 查看单个变量
printenv JAVA_HOME              # 查看单个变量

# 取消导出
unset JAVA_HOME                  # 删除变量
export -n JAVA_HOME             # 取消导出（变量仍存在但变为 Shell 变量）

# 永久设置环境变量
# 用户级（~/.bashrc, ~/.bash_profile, ~/.profile）
echo 'export JAVA_HOME=/usr/lib/jvm/java-17' >> ~/.bashrc
source ~/.bashrc

# 系统级（/etc/profile, /etc/environment）
echo 'export JAVA_HOME=/usr/lib/jvm/java-17' >> /etc/profile

# 单条命令设置环境变量
VAR=value command arg1 arg2     # 仅该命令生效
export VAR=value; command       # 先 export 再执行

- rwx r-x r--  file.txt
│  │   │   │
│  │   │   └── 其他（Other）: r--
│  │   └────── 所属组（Group）: r-x
│  └─────────── 所有者（User）: rwx
└────────────── 文件类型（-=文件, d=目录, l=链接）

chmod 755 file       # u=rwx, g=rx, o=rx
chmod 644 file       # u=rw, g=r, o=r
chmod 700 file       # u=rwx, g=---, o=---
chmod 4755 file      # 设置 SUID 位 + 755
chmod 0644 file      # 八进制写法

chmod u+x file       # 给所有者加执行权限
chmod g-w file       # 给所属组减写权限
chmod o=r file       # 设置其他用户为只读
chmod a+x file       # 给所有用户加执行权限
chmod u+x,g+w,o-r file  # 同时修改多组
chmod =rwx file      # 设置所有组为 rwx
chmod +x file        # 给所有用户加执行权限（等同 a+x）
chmod -x file        # 给所有用户减执行权限

chmod -R 755 /var/www/html   # 递归修改目录及所有子文件
chmod -R u+rwX /opt          # 递归添加权限（X 仅对目录添加执行权限）

chmod 4755 /usr/bin/passwd   # 设置 SUID
chmod 2775 /shared_dir       # 设置 SGID
chmod 1777 /tmp              # 设置 Sticky bit

# 查看当前权限
ls -la file.txt
# 输出: -rw-r--r-- 1 user group 100 Jan 1 12:00 file.txt

stat file.txt
# 输出: Access: (0644/-rw-r--r--)

# 修改权限示例
chmod +x script.sh           # 添加执行权限
chmod 600 id_rsa             # 私钥文件设置为仅所有者可读写
chmod 755 /var/www           # Web 目录设置为可读可执行
chmod -R 644 /var/www/html/*.html  # 批量修改文件

# 系统运行时长和负载
uptime
# 输出: 12:00:00 up 30 days,  1:23,  5 users,  load average: 1.23, 0.45, 0.12
# load average: 1/5/15 分钟平均进程数

# 实时系统监控
top
# top 交互操作：
# 1: 切换显示每个 CPU 核心
# P: 按 CPU 排序
# M: 按内存排序
# T: 按时间排序
# H: 显示线程
# k: 杀死进程
# r: 调整优先级

# 综合性能统计
vmstat 1                    # 每秒输出一次
# r: 运行队列长度
# b: 阻塞进程数
# si/so: 换入/换出
# bi/bo: 块设备读/写
# in: 中断数
# cs: 上下文切换数

# 多核 CPU 分析
mpstat -P ALL 1             # 每秒显示每个核心的统计

# 查找高 CPU 进程
ps aux --sort=-%cpu | head -10
top -bn1 | head -20

# 深入分析热点函数
perf top                    # 实时显示热点函数
perf record -g -p <PID>     # 记录进程调用栈
perf report                 # 分析记录结果

# 查看进程 CPU 使用
pidstat -u 1                # 每秒 CPU 统计
pidstat -r 1                # 上下文切换统计
pidstat -t -p <PID> 1       # 线程级 CPU 统计

# 内存概览
free -h
# 输出:
#               total        used        free      shared  buff/cache   available
# Mem:            16G         8G          4G        100M        4G          12G
# Swap:           8G          0B          8G

# 虚拟内存统计
vmstat 1
# si/so: 换页（内存不足时发生）
# bi/bo: 块设备 IO

# 进程内存排序
ps aux --sort=-%mem | head -10
top -o %MEM

# 深入分析进程内存
pmap <PID>                  # 查看进程内存映射
cat /proc/<PID>/smaps       # 详细内存统计

# OOM 排查
dmesg | grep -i "oom\|killed"
journalctl -k | grep -i "oom"

# 磁盘 IO 统计
iostat -x 1                # 每秒显示详细 IO 统计
# tps: 每秒传输数
# read/write: 读写速度
# %util: 设备利用率

# 查找高 IO 进程
iotop                       # 实时 IO 监控（需要 root）
iotop -o                    # 按 IO 排序

# 磁盘空间
df -h                       # 磁盘使用情况
du -sh *                    # 查看目录大小

# inode 使用
df -i                       # inode 使用情况

# 网络连接统计
ss -s                       # 连接概览
ss -tlnp                    # TCP 监听端口
ss -tnp                     # TCP 连接详情
netstat -s                  # 协议统计

# 网络流量
sar -n DEV 1                # 每秒网络流量
ifstat 1                    # 接口流量实时监控
iptraf-ng                   # 交互式网络监控

# 网络抓包
tcpdump -i eth0 -nn port 80 # 抓取 80 端口流量
wireshark                   # 图形化抓包分析

# DNS 排查
dig example.com             # DNS 查询
nslookup example.com        # DNS 查询

# 完整排查流程示例

# Step 1: 检查系统负载
uptime
# 如果 load average 持续高于 CPU 核数，说明 CPU 饱和

# Step 2: 使用 top 定位高资源进程
top
# 观察 %CPU、%MEM 列

# Step 3: 分析具体进程
PID=<从 top 获取>
perf top -p $PID             # 查看热点函数
strace -p $PID -c            # 统计系统调用
lsof -p $PID                 # 查看打开的文件

# Step 4: 检查子系统
iostat -x 1                  # 磁盘 IO
ss -s                        # 网络连接
free -h                      # 内存

# 查看 CPU 使用率
top -bn1 | head -20
# 重点关注：
# %Cpu(s): 80.0 us, 15.0 sy, 0.0 ni, 5.0 wa, 0.0 hi, 0.0 si, 0.0 st
# us: 用户态 CPU（应用程序）
# sy: 内核态 CPU（系统调用）
# wa: IO 等待
# st: 虚拟化偷取

# 查看负载
uptime
# load average 应 <= CPU 核数
# 如果 load >> 核数，说明 CPU 饱和

# 快速查看多核
nproc                      # CPU 核数
mpstat -P ALL 1            # 每个核心使用率

# top 实时查看
top
# 按 P 键按 CPU 排序
# 关注 %CPU 列最高的进程 PID

# 命令行方式
ps aux --sort=-%cpu | head -10
# 或
ps -eo pid,ppid,user,%cpu,%mem,cmd --sort=-%cpu | head -10

# 如果是 Java 进程
PID=$(ps aux --sort=-%cpu | awk 'NR==2{print $2}')
echo "High CPU PID: $PID"

# top 查看线程（H 键切换到线程模式）
top -H -p $PID
# 按 P 排序，找到高 CPU 线程的 TID

# ps 查看线程
ps -T -p $PID --sort=-%cpu | head -10
# TID 列是线程 ID

# 将 TID 转为十六进制（jstack 需要）
printf '0x%x\n' $TID

# 打印线程栈
jstack $PID > jstack.txt

# 在 jstack 输出中搜索高 CPU 线程（用十六进制 TID）
# 假设 TID=1234，十六进制为 0x4d2
grep -A 20 "0x4d2" jstack.txt

# 或使用 jcmd
jcmd $PID Thread.print > thread_dump.txt

# 分析 GC 情况
jstat -gc $PID 1000       # 每秒打印 GC 统计
jmap -histo:live $PID     # 堆内存直方图

# 使用 Arthas（阿里巴巴开源诊断工具）
# dashboard: 实时仪表盘
# thread -n 3: 最忙的前 3 个线程
# thread -b: 阻塞的线程

# perf top 实时显示热点函数
perf top -p $PID

# 记录并分析
perf record -F 99 -p $PID -g -- sleep 10
perf report

# strace 查看系统调用
strace -p $PID -c          # 统计系统调用
strace -p $PID -t          # 实时追踪

# gdb 附加（谨慎使用）
gdb -p $PID -batch -ex "thread apply all bt" -ex "detach"

# 采集进程信息
ps -p $PID -o pid,ppid,user,%cpu,%mem,stat,time,cmd > process_info.txt

# 采集线程栈（Java）
jstack -l $PID > jstack_$(date +%s).txt

# 采集堆内存（Java）
jmap -dump:format=b,file=heap_$(date +%s).hprof $PID

# 采集系统日志
dmesg > dmesg.txt
journalctl --no-pager > journal.txt

# 采集 perf 数据
perf record -F 99 -p $PID -g -- sleep 30
perf script > perf_script.txt

# Java CPU 100% 快速排查脚本

# 1. 找到高 CPU Java 进程
JAVA_PID=$(ps aux --sort=-%cpu | grep java | head -1 | awk '{print $2}')
echo "Java PID: $JAVA_PID"

# 2. 找到高 CPU 线程
HIGH_TID=$(top -H -p $JAVA_PID -bn1 | awk 'NR>6' | sort -k9 -rn | head -1 | awk '{print $1}')
echo "High CPU TID: $HIGH_TID"
HIGH_TID_HEX=$(printf '0x%x\n' $HIGH_TID)
echo "Hex TID: $HIGH_TID_HEX"

# 3. 打印线程栈
jstack $JAVA_PID > /tmp/jstack.txt

# 4. 查找高 CPU 线程
grep -A 30 "$HIGH_TID_HEX" /tmp/jstack.txt

# 5. 如果是 GC 问题
jstat -gc $JAVA_PID 1000 10

# 内存概览
free -h
# 输出:
#               total        used        free      shared  buff/cache   available
# Mem:            16Gi        8Gi         4Gi        100Mi       4Gi          12Gi
# Swap:           8Gi          0B          8Gi
#
# total: 总物理内存
# used: 已使用内存（buff/cache 也算）
# free: 完全空闲内存
# shared: 共享内存
# buff/cache: 缓冲区和缓存（可回收）
# available: 可用内存（free + 可回收 cache）
# Swap: 交换分区

# 详细内存统计
vmstat 1
# si: 每秒从交换分区换入内存的量
# so: 每秒从内存换出到交换分区的量
# bi: 块设备读
# bo: 块设备写

# 进程内存排序
ps aux --sort=-%mem | head -10
# 或
top -o %MEM

# 实际物理内存统计
smem -r -k    # 按实际物理内存排序

# Java 进程内存
jmap -heap $PID    # 查看堆内存配置
jmap -histo:live $PID  # 堆对象直方图

# OOM 排查
dmesg | grep -i "oom\|killed"
journalctl -k | grep -i "oom"

# 磁盘使用概览
df -h
# 输出:
# Filesystem      Size  Used Avail Use% Mounted on
# /dev/sda1       100G   60G   40G  60% /
# /dev/sdb1       500G  200G  300G  40% /data
# tmpfs            16G     0   16G   0% /dev/shm
#
# Size: 总容量
# Used: 已使用
# Avail: 可用
# Use%: 使用率

# inode 使用（防止小文件耗尽 inode）
df -i
# 输出:
# Filesystem     Inodes   IUsed  IFree IUse% Mounted on
# /dev/sda1    26214400 100000 26114400    1% /

# 目录大小
du -sh /var/log          # 查看单个目录大小
du -h --max-depth=1 /var # 查看一级子目录大小
du -sh * | sort -rh     # 排序显示当前目录下各项大小

# 磁盘 IO 统计
iostat -x 1
# 输出:
# Device         tps    read/s  write/s  %util
# sda            100    10MB/s   5MB/s   85%
#
# tps: 每秒 IO 次数
# read/write: 读写速率
# %util: 设备利用率

# 查找大文件
find / -type f -size +100M -exec ls -lh {} \; 2>/dev/null

# 内存不足排查
free -h
# 如果 available 很低：
# 1. 查看 swap 使用
free -h | grep Swap
# 2. 查看是否频繁换页
vmstat 1 | grep -v "^ *[0-9]" | awk '{if($3>0||$4>0) print "换页发生: si="$3" so="$4}'
# 3. 定位高内存进程
ps aux --sort=-%mem | head -5
# 4. 检查 OOM 日志
dmesg | grep -i oom

# 磁盘不足排查
df -h
# 如果某个分区接近满：
# 1. 定位大目录
du -h --max-depth=1 /partition | sort -rh
# 2. 查找大文件
find /partition -type f -size +100M
# 3. 清理不必要的文件
# 4. 检查日志轮转
cat /etc/logrotate.conf

# 查看内存 TOP 5 进程
ps aux --sort=-%mem | head -6

# 查看磁盘占用 TOP 10 目录
du -h /var/* 2>/dev/null | sort -rh | head -10

# 实时监控内存变化
watch -n 1 free -h

# 监控磁盘 IO
iostat -x 1 5     # 5 次，每秒

# Java 内存分析
jmap -dump:format=b,file=heap.hprof $PID
# 然后用 MAT 或 VisualVM 分析