Linux基础 ⭐

# 查看根目录下有哪些内容
ls /
# 典型输出：bin  boot  dev  etc  home  lib  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var

# 查看 /home 下的所有用户目录
ls /home
# 输出示例：alice  bob  charlie
 
# 每个用户登录后，默认进入自己的家目录
# 波浪号 ~ 是家目录的快捷表示
cd ~           # 等同于 cd /home/当前用户名
pwd            # 输出：/home/alice

# 查看 /etc 下的部分重要文件
ls /etc

# 查看 passwd 文件的某一行
cat /etc/passwd | grep alice
# 输出示例：
# alice:x:1001:1001:Alice Smith:/home/alice:/bin/bash
#  ①    ②  ③    ④      ⑤          ⑥         ⑦
# ① 用户名
# ② 密码占位符 (实际密码存储在 /etc/shadow 中)
# ③ UID (User ID，用户标识)
# ④ GID (Group ID，主组标识)
# ⑤ GECOS 字段 (用户备注/全名)
# ⑥ 家目录路径
# ⑦ 默认登录 Shell

# 查看 /var 下的典型子目录
ls /var
# 输出示例：cache  lib  lock  log  mail  opt  run  spool  tmp

# 查看 /var/log 下各文件的大小，按大小排序
du -sh /var/log/* | sort -rh | head -10
# 输出示例：
# 2.1G    /var/log/syslog
# 500M    /var/log/auth.log
# 120M    /var/log/kern.log
# ...

# 创建一个普通文本文件
echo "Hello, Linux!" > hello.txt
 
# 使用 ls -l 查看，第一个字符为 '-'
ls -l hello.txt
# -rw-r--r-- 1 alice alice 14 Jan 10 10:00 hello.txt
# ^
# '- ' 表示这是一个普通文件
 
# 使用 file 命令查看更详细的类型信息
file hello.txt
# hello.txt: ASCII text
 
file /usr/bin/ls
# /usr/bin/ls: ELF 64-bit LSB pie executable, x86-64 ...
# ELF 是 Linux 可执行文件的标准格式 (Executable and Linkable Format)

ls -ld /home
# drwxr-xr-x 5 root root 4096 Jan 10 10:00 /home
# ^
# 'd' 表示这是一个目录
 
# 目录的"大小"并不是其内部文件大小之和
# 而是目录文件本身（即映射表）占用的磁盘空间

┌──────────────────────────────────────┐
│        目录 /home 的内部结构          │
│  (本质是一张 name → inode 映射表)     │
├────────────┬─────────────────────────┤
│  文件名     │  inode 编号             │
├────────────┼─────────────────────────┤
│  .          │  131073  (指向自身)     │
│  ..         │  2       (指向父目录 /) │
│  alice      │  262145                │
│  bob        │  393217                │
└────────────┴─────────────────────────┘

# 创建符号链接：ln -s <目标> <链接名>
ln -s /usr/bin/python3 ~/my_python
 
# 查看符号链接
ls -l ~/my_python
# lrwxrwxrwx 1 alice alice 16 Jan 10 10:00 my_python -> /usr/bin/python3
# ^
# 'l' 表示符号链接，箭头指向目标
 
# 如果目标文件被删除，符号链接就会变成"悬空链接 (dangling link)"
rm /usr/bin/python3
ls -l ~/my_python
# lrwxrwxrwx 1 alice alice 16 Jan 10 10:00 my_python -> /usr/bin/python3  (红色闪烁，表示目标不存在)

# 硬链接示例
echo "original content" > original.txt     # 创建原始文件
ln original.txt hardlink.txt               # 创建硬链接 (不需要 -s)
 
ls -li original.txt hardlink.txt           # -i 显示 inode 编号
# 131074 -rw-r--r-- 2 alice alice 17 Jan 10 10:00 hardlink.txt
# 131074 -rw-r--r-- 2 alice alice 17 Jan 10 10:00 original.txt
#   ^                ^
# 相同 inode          引用计数为 2（有两个名字指向同一 inode）
 
rm original.txt                            # 删除原始文件
cat hardlink.txt                           # 硬链接仍然可以正常读取
# original content                         # 数据完好，因为 inode 引用计数从 2 降为 1，未归零

ls -l /dev/sda
# brw-rw---- 1 root disk 8, 0 Jan 10 10:00 /dev/sda
# ^                        ^^^^
# 'b' 块设备                主设备号=8, 次设备号=0
 
# /dev/sda  -> 第一块 SCSI/SATA 硬盘（整盘）
# /dev/sda1 -> 第一块硬盘的第一个分区
# /dev/sda2 -> 第一块硬盘的第二个分区
# /dev/nvme0n1 -> 第一块 NVMe SSD

ls -l /dev/null /dev/tty /dev/random
# crw-rw-rw- 1 root root 1, 3 Jan 10 10:00 /dev/null
# crw-rw-rw- 1 root tty  5, 0 Jan 10 10:00 /dev/tty
# crw-rw-rw- 1 root root 1, 8 Jan 10 10:00 /dev/random
# ^
# 'c' 字符设备

# 创建命名管道
mkfifo my_pipe
 
ls -l my_pipe
# prw-r--r-- 1 alice alice 0 Jan 10 10:00 my_pipe
# ^
# 'p' 表示命名管道
 
# 终端 1（写端）：向管道写入数据
echo "Hello from Terminal 1" > my_pipe    # 会阻塞，直到有进程从另一端读取
 
# 终端 2（读端）：从管道读取数据
cat < my_pipe                             # 读出 "Hello from Terminal 1"

ls -l /var/run/docker.sock
# srw-rw---- 1 root docker 0 Jan 10 10:00 /var/run/docker.sock
# ^
# 's' 表示套接字文件
 
# Docker 客户端正是通过这个 socket 文件与 Docker 守护进程通信
# 这也是为什么使用 Docker 通常需要将用户加入 docker 组

# 方法一：ls -l 看首字符
ls -l /dev/sda                # b -> 块设备
ls -l /etc/hostname           # - -> 普通文件
ls -ld /home                  # d -> 目录
 
# 方法二：file 命令（最智能，分析文件内容）
file /bin/ls                  # ELF 64-bit LSB executable ...
file /etc/passwd              # ASCII text
file /dev/null                # character special (1/3)
 
# 方法三：stat 命令（最详细，显示 inode 元信息）
stat /etc/hostname
# 输出包含：File type, Inode number, Links count, Access/Modify/Change time 等

# 尝试直接运行一个没有执行权限的脚本
$ ./deploy.sh
# bash: ./deploy.sh: Permission denied   <-- 缺少 x 权限
 
# 赋予执行权限后再运行
$ chmod +x deploy.sh                     # 添加执行权限
$ ./deploy.sh                            # 现在可以正常运行了

# 实验：目录权限 vs 文件权限的优先关系
$ ls -la /tmp/testdir/
# drwxrwxrwx  2 root root  4096 ...  .        <-- 目录对所有人开放 w 权限
# -r--------  1 root root    13 ...  secret   <-- 文件仅 root 可读
 
$ whoami
# student                                      # 当前用户是 student
 
$ cat /tmp/testdir/secret
# cat: /tmp/testdir/secret: Permission denied  # 无法读取文件内容 ✗
 
$ rm /tmp/testdir/secret
# rm: remove write-protected file? y
# (文件被成功删除!)                              # 但可以删除文件 ✓ (因为目录有 w)

  r   w   x
  4   2   1     <-- 十进制权重
  1   1   1     <-- 二进制位

# 查看文件的 Owner
$ ls -l config.yaml
# -rw-r--r--  1  alice  devteam  256  Jun 10 14:30  config.yaml
#                ^^^^^  ^^^^^^^
#                Owner  Group

# 查看当前用户所属的所有组
$ groups
# alice devteam docker sudo
 
# 查看系统中某个组的所有成员
$ getent group devteam
# devteam:x:1001:alice,bob,charlie

-  rwx  r-x  r--
│  ───  ───  ───
│   │    │    └── Others 权限: r-- (仅读)
│   │    └─────── Group  权限: r-x (读+执行)
│   └──────────── Owner  权限: rwx (完全权限)
└──────────────── 文件类型: - 普通文件 / d 目录 / l 链接

# alice 既是 Owner 又在 devteam 组中
$ ls -l report.txt
# ----rwx---  1  alice  devteam  1024  ...  report.txt
 
# alice 尝试读取自己的文件
$ cat report.txt
# Permission denied!
# 原因: alice 匹配到 Owner (---), 没有 r 权限
# 即使 Group (rwx) 完全开放, 也不会被使用!

$ ls -l /usr/bin/passwd
# -rwsr-xr-x  1  root  root  68208  ...  /usr/bin/passwd
#    ^
#    s = SUID 被设置
 
# 当普通用户执行 passwd 时:
# 1. 进程的 Effective UID 临时变为 root (文件 Owner)
# 2. 进程以 root 权限写入 /etc/shadow
# 3. 执行完毕后权限恢复

$ ls -ld /tmp
# drwxrwxrwt  24  root  root  4096  ...  /tmp
#          ^
#          t = Sticky Bit 被设置
 
# 效果: 所有用户都能在 /tmp 中创建文件
# 但只能删除自己创建的文件, 不能删除别人的

WHO（谁）    OPERATOR（操作）    PERMISSION（权限）
─────────    ─────────────────    ──────────────────
u = Owner    + = 添加权限         r = 读
g = Group    - = 移除权限         w = 写
o = Others   = = 精确设置         x = 执行
a = All                          s = SUID/SGID
                                 t = Sticky Bit

# ---- 常用示例 ----
 
# 给 Owner 添加执行权限
$ chmod u+x script.sh          # Owner: --- → --x (叠加)
 
# 给所有人添加读权限
$ chmod a+r document.txt        # 所有角色都获得 r
 
# 移除 Others 的写和执行权限
$ chmod o-wx config.yaml        # Others: rwx → r--
 
# 精确设置: Owner 读写执行, Group 读执行, Others 仅读
$ chmod u=rwx,g=rx,o=r app.bin  # 结果: rwxr-xr-- (等价于 754)
 
# 同时操作多个角色
$ chmod ug+rw shared.txt        # Owner 和 Group 都添加读写
 
# 设置 SUID
$ chmod u+s /usr/local/bin/tool # 设置 SUID 位
 
# 设置 Sticky Bit
$ chmod +t /shared/tmp          # 设置粘滞位

# ---- 常用八进制权限 ----
 
$ chmod 755 app.bin
#       ^^^
#       │││
#       ││└─ Others:  r-x (4+0+1=5)
#       │└── Group:   r-x (4+0+1=5)
#       └─── Owner:   rwx (4+2+1=7)
# 最终权限: -rwxr-xr-x
# 适用场景: 可执行程序、脚本、目录
 
$ chmod 644 readme.md
# 最终权限: -rw-r--r--
# 适用场景: 普通文件(Owner可写, 其他人只读)
 
$ chmod 600 id_rsa
# 最终权限: -rw-------
# 适用场景: SSH 私钥、敏感配置文件(仅 Owner 可读写)
 
$ chmod 700 .ssh/
# 最终权限: drwx------
# 适用场景: SSH 目录(仅 Owner 可进入)
 
$ chmod 4755 /usr/local/bin/tool
#       ^^^^
#       │
#       └─── 4 = SUID
# 最终权限: -rwsr-xr-x
 
$ chmod 1777 /tmp
#       ^^^^
#       │
#       └─── 1 = Sticky Bit
# 最终权限: drwxrwxrwt

# -R 递归修改目录下所有文件和子目录的权限
$ chmod -R 755 /var/www/html/    # 递归设置整个 Web 目录
 
# 更精细的做法: 目录和文件分开设置
$ find /var/www -type d -exec chmod 755 {} \;   # 所有目录设为 755
$ find /var/www -type f -exec chmod 644 {} \;   # 所有文件设为 644
# 原因: 目录需要 x 权限才能进入, 但普通文件不需要 x
 
# chown 修改文件的 Owner 和 Group
$ chown alice:devteam project/   # 修改 Owner 为 alice, Group 为 devteam
$ chown -R www-data:www-data /var/www/  # 递归修改整个 Web 目录的归属

最终权限 = 基础权限 - umask
 
文件基础权限: 666 (rw-rw-rw-)    ← 文件默认不给 x，安全考虑
目录基础权限: 777 (rwxrwxrwx)

# 查看当前 umask
$ umask
# 0022                              # 常见默认值
 
# 计算过程:
# 新建文件: 666 - 022 = 644 → -rw-r--r--
# 新建目录: 777 - 022 = 755 → drwxr-xr-x
 
$ touch newfile.txt
$ ls -l newfile.txt
# -rw-r--r--  1 alice alice  0  ...  newfile.txt   ← 确认为 644
 
$ mkdir newdir
$ ls -ld newdir
# drwxr-xr-x  2 alice alice  4096  ...  newdir      ← 确认为 755
 
# 修改 umask (仅对当前 Shell 会话生效)
$ umask 077                         # 更严格: 仅 Owner 有权限
# 新建文件: 666 - 077 = 600 → -rw-------
# 新建目录: 777 - 077 = 700 → drwx------

chmod 640 data.csv

# 最基础的用法：列出当前目录下的文件和子目录
ls
 
# -l (long format): 以长格式显示，包含权限、链接数、属主、属组、大小、修改时间
ls -l
 
# -a (all): 显示所有文件，包括以 . 开头的隐藏文件（如 .bashrc）
ls -a
 
# -h (human-readable): 文件大小以 KB/MB/GB 等人类可读单位显示，常与 -l 联用
ls -lh
 
# -R (recursive): 递归列出所有子目录的内容
ls -R
 
# -t (time): 按修改时间排序，最新的文件排在最前面
ls -lt
 
# -S (size): 按文件大小排序，最大的排在前面
ls -lS
 
# 组合使用：列出 /etc 目录下所有文件（含隐藏），按时间倒序，人类可读格式
ls -alht /etc

-rw-r--r--  1  root  root  4096  Jan 10 09:30  config.txt
│└────┬───┘  │  │     │     │     └─────┬──────┘  └────┬────┘
│     │      │  │     │     │           │              │
│  权限位    │ 属主  属组  文件大小   最后修改时间     文件名
│(rwx组合)   │
│          硬链接数
│
└── 文件类型: - 普通文件, d 目录, l 符号链接

# 切换到绝对路径
cd /var/log                # 进入 /var/log 目录
 
# 切换到相对路径
cd ../                     # 返回上一级目录（.. 代表父目录）
cd ./subdir                # 进入当前目录下的 subdir（. 代表当前目录）
 
# 回到用户主目录（三种等价写法）
cd                         # 不带参数，直接回 $HOME
cd ~                       # ~ 是 $HOME 的快捷符号
cd $HOME                   # 显式使用环境变量
 
# 回到上一次所在的目录（非常实用的来回跳转）
cd -                       # 等价于 cd $OLDPWD，并打印目标路径

# 显示当前所在的绝对路径
pwd                        # 输出如 /home/alice/projects
 
# -P (physical): 显示物理路径，解析所有符号链接
pwd -P
 
# -L (logical): 显示逻辑路径（默认），保留符号链接的名字
pwd -L

# 假设 /opt/app 是指向 /var/lib/myapp 的符号链接
cd /opt/app
pwd                        # 输出: /opt/app        （逻辑路径）
pwd -P                     # 输出: /var/lib/myapp   （物理真实路径）

# 创建单个目录
mkdir myproject
 
# -p (parents): 递归创建多层目录，父目录不存在时自动创建，已存在时不报错
mkdir -p a/b/c/d           # 一次性创建 a → b → c → d 的嵌套结构
 
# -m (mode): 创建目录的同时指定权限
mkdir -m 755 deploy        # 创建 deploy 目录，权限为 rwxr-xr-x
 
# -v (verbose): 显示创建过程
mkdir -pv project/{src,bin,doc}
# 输出:
# mkdir: created directory 'project'
# mkdir: created directory 'project/src'
# mkdir: created directory 'project/bin'
# mkdir: created directory 'project/doc'

# 删除单个文件
rm file.txt
 
# -i (interactive): 删除前逐个确认，防止误删
rm -i important.conf       # 提示 "rm: remove regular file 'important.conf'?"
 
# -f (force): 强制删除，忽略不存在的文件，不提示确认
rm -f temp.log
 
# -r (recursive): 递归删除目录及其所有内容（删除目录必须加此选项）
rm -r old_project/
 
# ⚠️ 经典的"自杀式"命令（绝对不要在生产环境执行！）
# rm -rf /                 # 递归强制删除根目录下的一切 → 系统毁灭
# rm -rf /*                # 同上，通配符展开后效果一样致命
 
# 更安全的做法：删除前先用 ls 确认目标
ls target_dir/             # 先看看里面有什么
rm -ri target_dir/         # 再用交互模式逐个确认删除

# 查看文件内容（整个文件一次性输出到终端）
cat /etc/hostname
 
# 查看多个文件（按顺序拼接输出，这才是 cat 名字的由来）
cat header.txt body.txt footer.txt
 
# -n (number): 显示行号
cat -n /etc/passwd
 
# -b (number-nonblank): 只对非空行编号
cat -b script.sh
 
# -A (show-all): 显示不可见字符（如行尾的 $、Tab 显示为 ^I）
cat -A config.ini          # 排查隐藏字符问题时非常有用
 
# 利用重定向创建文件（简易写入）
cat > newfile.txt << EOF
第一行内容
第二行内容
EOF
# 这里使用了 Here Document (<<EOF...EOF) 语法
 
# 拼接文件到新文件
cat part1.log part2.log part3.log > combined.log

# 基本用法：在文件中搜索包含 "error" 的行
grep "error" /var/log/syslog
 
# -i (ignore-case): 忽略大小写
grep -i "warning" app.log          # 匹配 Warning, WARNING, warning 等
 
# -n (line-number): 显示匹配行的行号
grep -n "TODO" main.c              # 输出如 "42:// TODO: fix this bug"
 
# -r (recursive): 递归搜索目录下的所有文件
grep -r "database" /etc/           # 在 /etc 下所有文件中搜索
 
# -l (files-with-matches): 只输出包含匹配的文件名，不输出具体行
grep -rl "password" /etc/          # 快速定位哪些配置文件含有密码字段
 
# -v (invert-match): 反向匹配，输出 **不包含** 模式的行
grep -v "^#" /etc/fstab            # 过滤掉注释行（以 # 开头的行）
 
# -c (count): 只输出匹配的行数
grep -c "404" access.log           # 统计 404 错误出现的次数
 
# -w (word-regexp): 全词匹配，避免部分匹配
grep -w "port" config.txt          # 匹配 "port" 但不匹配 "export" 或 "support"
 
# -E (extended-regexp): 使用扩展正则表达式（等价于 egrep）
grep -E "error|fatal|panic" kern.log   # 匹配多个模式（OR 逻辑）
 
# -A/-B/-C (after/before/context): 显示匹配行的上下文
grep -A 3 "Exception" app.log      # 显示匹配行及其后 3 行
grep -B 2 "Exception" app.log      # 显示匹配行及其前 2 行
grep -C 2 "Exception" app.log      # 显示匹配行及其前后各 2 行
 
# 与管道结合：经典的过滤用法
ps aux | grep "nginx"              # 从进程列表中筛选 nginx 相关进程
dmesg | grep -i "usb"             # 从内核日志中筛选 USB 相关信息

.         匹配任意单个字符
*         前一个字符出现 0 次或多次
^         行首锚定
$         行尾锚定
[]        字符集合，如 [a-z] 匹配小写字母
[^]       取反字符集，如 [^0-9] 匹配非数字
\{n,m\}   前一个字符出现 n 到 m 次（BRE 语法）
|         OR 逻辑（ERE，需要 grep -E）
()        分组（ERE，需要 grep -E）

# 基本语法: find [搜索路径] [条件表达式] [动作]
 
# 按名称查找（-name 区分大小写，-iname 不区分）
find /home -name "*.log"           # 在 /home 下查找所有 .log 文件
find / -iname "readme*"            # 全盘搜索，不区分大小写
 
# 按文件类型查找（-type）
find /etc -type f                  # f = 普通文件
find /var -type d                  # d = 目录
find /dev -type l                  # l = 符号链接
 
# 按大小查找（-size）
find / -size +100M                 # 大于 100MB 的文件
find /tmp -size -1k                # 小于 1KB 的文件
find /var/log -size +10M -size -1G # 大于 10MB 且小于 1GB
 
# 按时间查找（-mtime 修改时间，-atime 访问时间，-ctime 状态变更时间）
find /var/log -mtime -7            # 最近 7 天内修改过的文件
find /tmp -atime +30               # 超过 30 天未访问的文件
 
# 按权限查找（-perm）
find / -perm -4000                 # 查找所有设置了 SUID 位的文件（安全审计）
find /home -perm 777               # 查找权限为 777 的文件（潜在安全隐患）
 
# 按用户/组查找
find /home -user alice             # 查找属于 alice 用户的文件
find /var -group www-data          # 查找属于 www-data 组的文件
 
# 组合条件（-and 默认, -or, -not）
find /etc -name "*.conf" -type f   # 名为 *.conf 且是普通文件（隐含 AND）
find /var -name "*.log" -or -name "*.txt"  # .log 或 .txt 文件
find /home -not -user root         # 不属于 root 的文件
 
# 找到后执行动作（-exec）
find /tmp -name "*.tmp" -exec rm {} \;         # 删除所有 .tmp 文件
# {} 是占位符，代表 find 找到的每个文件路径
# \; 是 -exec 的结束标记（反斜杠转义分号）
 
find /var/log -name "*.log" -exec ls -lh {} \; # 列出所有 .log 文件的详细信息
 
# 更高效的写法：用 + 替代 \;，将多个文件一次性传递给命令
find /tmp -name "*.tmp" -exec rm {} +          # 批量删除，减少进程创建次数
 
# 与 xargs 结合（处理大量文件时更高效）
find /var/log -name "*.log" | xargs ls -lh
find . -name "*.c" | xargs grep "malloc"       # 在所有 C 源文件中搜索 malloc

# 查看当前终端关联的进程
ps                                 # 只显示当前 Shell 会话的进程
 
# 查看所有进程（两大风格）
ps aux                             # BSD 风格（无短横线），最常用
ps -ef                             # UNIX/System V 风格（带短横线）
 
# ps aux 各列含义：
# USER  PID  %CPU  %MEM  VSZ   RSS   TTY  STAT  START  TIME  COMMAND
# 用户  进程ID CPU占用 内存占用 虚拟内存 物理内存 终端 状态  启动时间 CPU时间 命令名
 
# 查看进程树（显示父子关系）
ps auxf                            # f = forest，ASCII 树形显示
ps -ejH                            # System V 风格的层级显示
 
# 查看特定用户的进程
ps -u alice                        # 查看 alice 用户的所有进程
 
# 自定义输出列
ps -eo pid,ppid,uid,cmd,%mem,%cpu --sort=-%mem
# -e: 所有进程
# -o: 自定义输出字段（pid=进程ID, ppid=父进程ID, uid=用户ID, cmd=命令）
# --sort=-%mem: 按内存使用率降序排列（- 表示降序）
 
# 经典组合：查找特定进程
ps aux | grep nginx                # 搜索 nginx 进程
ps aux | grep "[n]ginx"            # 技巧：用正则避免 grep 自身出现在结果中

状态码      含义
─────────────────────────────────────────────────────
R          Running / Runnable — 正在运行或在就绪队列中
S          Sleeping (Interruptible) — 可中断睡眠，等待事件
D          Sleeping (Uninterruptible) — 不可中断睡眠，通常等待 I/O
T          Stopped — 被信号暂停（如 Ctrl+Z 或 SIGSTOP）
Z          Zombie — 僵尸进程，已终止但父进程尚未回收
─────────────────────────────────────────────────────
附加标记：
<          高优先级进程（not nice to others）
N          低优先级进程（nice to others）
s          Session leader（会话首进程）
l          多线程（使用 CLONE_THREAD）
+          前台进程组成员

# 启动 top（默认每 3 秒刷新一次）
top
 
# top 界面上半部分（系统摘要区）示例：
# top - 14:30:01 up 5 days, 3:22, 2 users, load average: 0.52, 0.68, 0.71
#   │                                                      └── 1分钟/5分钟/15分钟平均负载
# Tasks: 213 total, 1 running, 210 sleeping, 0 stopped, 2 zombie
#   │                                                     └── 2个僵尸进程！
# %Cpu(s): 12.5 us, 3.2 sy, 0.0 ni, 83.1 id, 1.0 wa, 0.0 hi, 0.2 si
#           │       │              │          │
#         用户态  内核态      空闲百分比   I/O等待（高=磁盘瓶颈）
# MiB Mem: 7963.4 total, 2105.8 free, 3842.1 used, 2015.5 buff/cache
# MiB Swap: 2048.0 total, 2048.0 free, 0.0 used.  3621.3 avail Mem

# top 运行中的交互快捷键：
# q     — 退出 top
# P     — 按 CPU 使用率排序（默认）
# M     — 按内存使用率排序
# T     — 按运行时间排序
# k     — 输入 PID 并发送信号（默认 SIGTERM）杀死进程
# 1     — 展开显示每个 CPU 核心的独立使用率
# c     — 切换显示完整命令行路径
# H     — 切换线程视图（显示线程而非进程）
 
# 命令行参数
top -d 1                           # 每 1 秒刷新一次
top -p 1234                        # 只监控 PID 为 1234 的进程
top -u alice                       # 只显示 alice 用户的进程
top -bn1                           # 批处理模式，只输出一次（常用于脚本采集）

# 基本用法：向指定 PID 发送信号
kill 1234                          # 默认发送 SIGTERM (15)，请求进程优雅退出
 
# 指定信号（三种写法等价）
kill -9 1234                       # 方式一：信号编号
kill -SIGKILL 1234                 # 方式二：信号全名
kill -KILL 1234                    # 方式三：信号简名（去掉 SIG 前缀）
 
# 查看所有可用信号
kill -l                            # 列出所有信号编号和名称
 
# 向进程组发送信号（负号 PID 表示进程组）
kill -TERM -1234                   # 向 PGID 为 1234 的整个进程组发送 SIGTERM
 
# killall：按进程名发送信号
killall nginx                      # 向所有名为 nginx 的进程发送 SIGTERM
killall -9 nginx                   # 强制杀死所有 nginx 进程
 
# pkill：支持模式匹配的进程信号发送
pkill -f "python.*server"          # 向命令行匹配 "python.*server" 的进程发信号

编号   名称        默认行为             用途
──────────────────────────────────────────────────────────────
 1    SIGHUP      终止              终端断开；常用于通知守护进程重新加载配置
 2    SIGINT      终止              键盘中断 Ctrl+C
 3    SIGQUIT     终止+Core Dump    键盘退出 Ctrl+\（生成核心转储用于调试）
 9    SIGKILL     强制终止           ☠ 不可捕获、不可忽略，内核直接清除进程
15    SIGTERM     终止              优雅终止请求（可被进程捕获并做清理工作）
18    SIGCONT     继续执行           恢复被暂停的进程（与 fg / bg 配合）
19    SIGSTOP     暂停              ☠ 不可捕获，强制暂停进程
20    SIGTSTP     暂停              键盘暂停 Ctrl+Z（可被捕获）

# 语法: chmod [who][operator][permission] file
# who:        u(user/属主), g(group/属组), o(others/其他), a(all/所有人)
# operator:   +(添加), -(移除), =(设置为精确值)
# permission: r(读), w(写), x(执行)
 
# 给文件属主添加执行权限
chmod u+x script.sh                # 属主现在可以执行这个脚本
 
# 给属组和其他人移除写权限
chmod go-w sensitive.conf          # 只有属主能写
 
# 给所有人添加读权限
chmod a+r public.html              # 等价于 chmod +r public.html
 
# 精确设置：属主读写执行，属组读执行，其他人只读
chmod u=rwx,g=rx,o=r deploy.sh
 
# -R (recursive): 递归修改目录及其所有内容的权限
chmod -R 755 /var/www/html         # 整个 web 目录设为 755

权限     二进制     八进制
───────────────────────────
---       000        0
--x       001        1
-w-       010        2
-wx       011        3
r--       100        4
r-x       101        5
rw-       110        6
rwx       111        7

# 三位八进制分别代表: 属主 | 属组 | 其他人
chmod 755 script.sh                # rwxr-xr-x  属主全权限，其他人可读可执行
chmod 644 document.txt             # rw-r--r--  属主读写，其他人只读
chmod 700 private/                 # rwx------  仅属主可访问
chmod 600 id_rsa                   # rw-------  SSH 私钥的标准权限
chmod 777 /tmp/shared              # rwxrwxrwx  所有人全权限（通常不推荐）

# SUID (Set User ID) — 八进制前缀 4
chmod 4755 /usr/bin/passwd
# 效果：任何用户执行 passwd 时，进程以文件属主(root)的身份运行
# 这就是为什么普通用户能通过 passwd 命令修改 /etc/shadow（root所有的文件）
 
# SGID (Set Group ID) — 八进制前缀 2
chmod 2755 /opt/team_project/
# 效果(对目录)：在该目录下新建的文件自动继承目录的属组，而非创建者的主组
# 适用于团队协作目录
 
# Sticky Bit — 八进制前缀 1
chmod 1777 /tmp
# 效果(对目录)：目录中的文件只能由文件属主或 root 删除，即使其他人有 w 权限
# /tmp 就是经典的 Sticky Bit 目录，防止用户互相删除临时文件

# ls -l 中特殊权限的显示方式：
-rwsr-xr-x    →  SUID 生效（属主执行位显示 s 而非 x）
-rwxr-sr-x    →  SGID 生效（属组执行位显示 s）
drwxrwxrwt    →  Sticky Bit 生效（其他人执行位显示 t）
 
# 如果原本没有执行权限，则显示大写：
-rwSr--r--    →  SUID 设置但属主无执行权限（S = SUID + 无 x）

# 修改属主
chown alice file.txt               # 将 file.txt 的属主改为 alice
 
# 同时修改属主和属组（冒号分隔）
chown alice:developers project/    # 属主改为 alice，属组改为 developers
 
# 只修改属组（属主留空，冒号保留）
chown :developers file.txt         # 等价于 chgrp developers file.txt
 
# -R (recursive): 递归修改目录及所有子内容的归属
chown -R www-data:www-data /var/www/html   # Web 服务器经典操作
 
# --reference: 参照另一个文件的归属来设置
chown --reference=template.conf newfile.conf
 
# chgrp: 专门修改属组的命令（chown 的子集功能）
chgrp staff report.pdf             # 将 report.pdf 的属组改为 staff

# 场景一：部署 Web 应用后，将文件归属给 Web 服务器用户
sudo chown -R www-data:www-data /var/www/myapp/
 
# 场景二：解压 tarball 后恢复正确的归属关系
sudo tar xzf app.tar.gz -C /opt/
sudo chown -R appuser:appgroup /opt/app/
 
# 场景三：创建共享目录，设置 SGID 确保组归属一致
sudo mkdir /opt/shared
sudo chown root:team /opt/shared
sudo chmod 2775 /opt/shared        # SGID + rwxrwxr-x
# 此后 team 组成员在此目录创建的文件自动属于 team 组

# ps aux 各字段解析
# a: 显示所有用户的进程（不限于当前终端）
# u: 以用户友好的格式显示（包含 CPU、内存占用等）
# x: 包含没有控制终端的进程（如守护进程 daemon）
ps aux

USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.3 169436 13076 ?        Ss   Feb25   0:05 /sbin/init
root         2  0.0  0.0      0     0 ?        S    Feb25   0:00 [kthreadd]
mysql     1234  0.2  5.1 1842356 205432 ?      Ssl  Feb25   3:42 /usr/sbin/mysqld
alice     5678  0.0  0.1  22812  5320 pts/0    S+   10:30   0:00 vim notes.txt
root      9012  0.0  0.0      0     0 ?        I<   Feb25   0:00 [kworker/0:0H]

# ┌─────────────────────────────────────────────────────────────────────────┐
# │ 字段       含义                          典型值/说明                     │
# ├─────────────────────────────────────────────────────────────────────────┤
# │ USER       进程所有者的用户名              root, alice, mysql            │
# │ PID        进程ID (Process ID)            唯一标识，内核分配             │
# │ %CPU       CPU 占用百分比                  基于进程生命周期的平均值       │
# │ %MEM       物理内存占用百分比              RSS / 总物理内存               │
# │ VSZ        虚拟内存大小 (KB)              包含 swap + 共享库映射         │
# │ RSS        常驻内存集大小 (KB)            实际在物理内存中的部分          │
# │ TTY        关联的终端                     pts/0=伪终端, ?=无终端(daemon) │
# │ STAT       进程状态码                     S=睡眠, R=运行, Z=僵尸等      │
# │ START      进程启动时间                   若超过24h则显示日期            │
# │ TIME       累计 CPU 使用时间              格式 分:秒                     │
# │ COMMAND    启动进程的完整命令行            带路径和参数                   │
# └─────────────────────────────────────────────────────────────────────────┘

# STAT 状态码详解
# ──────────────────────────────────
# 主状态（第一个字符）：
#   R  Running / Runnable     正在运行 或 在运行队列中等待 CPU
#   S  Interruptible Sleep    可中断睡眠，等待某事件（如 I/O 完成）
#   D  Uninterruptible Sleep  不可中断睡眠，通常在等待磁盘 I/O（此时 kill -9 也杀不掉！）
#   T  Stopped                已停止，通常收到 SIGSTOP 或 SIGTSTP (Ctrl+Z)
#   Z  Zombie                 僵尸进程，已退出但父进程尚未回收其退出状态
#   I  Idle                   空闲的内核线程（Linux 4.14+ 才有）
#
# 修饰字符（第二个字符起）：
#   <  高优先级（nice 值为负）
#   N  低优先级（nice 值为正）
#   L  有页面锁定在内存中（用于实时进程或 I/O）
#   s  会话首进程（session leader）
#   l  多线程（使用 clone() 创建的轻量级进程）
#   +  属于前台进程组
#
# 组合举例：
#   Ss   → 可中断睡眠 + 会话首进程（如 init, sshd）
#   R+   → 正在运行 + 前台进程
#   Ssl  → 可中断睡眠 + 会话首进程 + 多线程（如 mysqld）
#   D+   → 不可中断睡眠 + 前台（可能在执行高密度磁盘 I/O）
#   Z    → 僵尸进程（需要父进程 wait() 回收）

# -e: 等同于 -A，显示所有进程
# -f: full-format，显示完整信息（包含 PPID 父进程ID）
ps -ef

UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 Feb25 ?        00:00:05 /sbin/init
root       456     1  0 Feb25 ?        00:00:12 /usr/lib/systemd/systemd-journald
alice     5678  3456  0 10:30 pts/0    00:00:00 vim notes.txt

# 1. 查找特定进程名（最常用）
#    grep -v grep: 排除 grep 自身（因为 grep java 本身也包含 "java"）
ps aux | grep java | grep -v grep
 
# 2. 更优雅的写法：用方括号技巧避免 grep 匹配自身
#    [j]ava 这个正则匹配 "java"，但 grep 命令本身显示为 "grep [j]ava"，不会自匹配
ps aux | grep '[j]ava'
 
# 3. 查看进程树结构（--forest 以 ASCII 树形展示父子关系）
ps -ef --forest
 
# 4. 查看特定用户的进程
#    -u alice: 只显示用户 alice 的进程
ps -u alice
 
# 5. 按指定列输出（自定义格式）
#    -o: 指定输出列，pid=进程ID, ppid=父进程ID, %cpu=CPU占用, %mem=内存占用, cmd=命令
ps -eo pid,ppid,%cpu,%mem,cmd --sort=-%cpu | head -10
#    --sort=-%cpu: 按 CPU 使用率降序排列
#    head -10: 只看前10行（CPU 占用最高的10个进程）
 
# 6. 查看线程级信息
#    -L: 显示线程（LWP = Light Weight Process 轻量级进程）
ps -eLf | grep mysqld
 
# 7. 查看特定 PID 的详细信息
#    -p 1234: 只查看 PID 为 1234 的进程
ps -fp 1234

# /proc 中每个数字目录对应一个进程，目录名就是 PID
ls /proc/ | grep -E '^[0-9]+$' | head -5
# 输出: 1  2  3  5  7  ...
 
# 查看 PID=1 的进程状态信息
cat /proc/1/status
# 输出包含:
#   Name:   systemd          ← 进程名
#   State:  S (sleeping)     ← 运行状态
#   Tgid:   1                ← 线程组ID（主线程的PID）
#   Pid:    1                ← 进程ID
#   PPid:   0                ← 父进程ID（0表示由内核直接创建）
#   Threads: 1               ← 线程数
#   VmRSS:  13076 kB         ← 常驻内存
 
# 查看进程的命令行参数
cat /proc/1/cmdline | tr '\0' ' '
# 输出: /sbin/init
# 注意: cmdline 中参数以 \0 (null) 分隔，tr 将其替换为空格方便阅读
 
# 查看进程打开的文件描述符
ls -la /proc/1/fd/
# 输出: 0 -> /dev/null       ← 标准输入
#        1 -> /dev/null       ← 标准输出
#        2 -> /dev/null       ← 标准错误
#        3 -> socket:[12345]  ← 网络套接字

# 直接运行 top，进入交互界面
top
 
# 常用交互键（在 top 界面内按）：
#   P  → 按 CPU 使用率排序（默认）
#   M  → 按内存使用率排序
#   k  → 输入 PID 杀死进程
#   q  → 退出 top
#   1  → 显示每个 CPU 核心的独立使用率
#   H  → 显示线程视图
 
# 批处理模式（非交互，适合脚本中使用）
#   -b: batch mode    -n 1: 只刷新一次    -o %CPU: 按CPU排序
top -bn1 -o %CPU | head -20

# 基本语法: kill [选项] <PID>
 
# 1. 发送默认信号 SIGTERM (15) —— 请求进程优雅退出
#    进程收到 SIGTERM 后可以执行清理工作（关闭文件、释放锁、保存状态）再退出
kill 1234
 
# 2. 等价于上面的写法（显式指定信号）
kill -15 1234       # 用信号编号
kill -SIGTERM 1234  # 用信号名称（带 SIG 前缀）
kill -TERM 1234     # 用信号名称（省略 SIG 前缀）
 
# 3. 强制杀死进程 —— SIGKILL (9)
#    不给进程任何清理机会，内核直接回收资源
#    ⚠️ 应作为最后手段！可能导致数据丢失、临时文件残留、子进程变孤儿
kill -9 1234
 
# 4. 暂停和恢复进程
kill -STOP 1234     # 暂停进程（进程状态变为 T）
kill -CONT 1234     # 恢复进程继续运行
 
# 5. 通知守护进程重新加载配置
#    许多服务（nginx, sshd, apache）用 SIGHUP 触发配置热加载
kill -HUP $(cat /var/run/nginx.pid)
#    等同于: systemctl reload nginx
 
# 6. 向整个进程组发送信号（PID 前加负号）
#    进程组 PGID=1234 的所有进程都会收到信号
kill -TERM -1234
 
# 7. 查看所有可用信号
kill -l

# killall: 按精确进程名发送信号
#   杀死所有名为 "python3" 的进程
killall python3
 
#   向所有 nginx worker 发送 SIGHUP（重新加载）
killall -HUP nginx
 
# pkill: 按模式匹配进程名/属性（更灵活）
#   杀死命令行中包含 "my_script" 的进程（支持正则）
pkill -f "my_script.py"
#   -f: 匹配完整命令行（而非仅进程名）
 
#   只杀死属于 alice 用户的 python 进程
pkill -u alice python
 
#   杀死特定终端上的所有进程
pkill -t pts/2

# 生产环境的标准停止流程
PID=1234
 
kill -TERM $PID          # 第一步：请求优雅退出
sleep 5                  # 第二步：等待 5 秒
 
if kill -0 $PID 2>/dev/null; then   # 第三步：检查进程是否还活着
    # kill -0 不发送真正信号，只检查进程是否存在（返回 0 表示存在）
    echo "进程未响应 SIGTERM，强制终止..."
    kill -9 $PID         # 第四步：强制杀死
fi

// signal_demo.c — 演示信号捕获机制
#include <stdio.h>    // printf 输出
#include <signal.h>   // signal(), SIGTERM, SIGINT 等信号定义
#include <stdlib.h>   // exit() 进程退出
#include <unistd.h>   // sleep() 暂停
 
// 自定义信号处理函数（当收到 SIGTERM 时被内核回调）
void graceful_shutdown(int signum) {
    // signum: 收到的信号编号
    printf("\n收到信号 %d (SIGTERM)，正在执行清理...\n", signum);
    
    // 这里可以执行清理工作：关闭数据库连接、保存缓存、写日志等
    printf("关闭文件描述符...\n");
    printf("保存应用状态...\n");
    printf("清理完成，进程正常退出。\n");
    
    exit(0);   // 正常退出，退出码为 0
}
 
int main() {
    // 注册信号处理函数：当收到 SIGTERM 时，调用 graceful_shutdown
    // signal() 是最简单的注册方式（生产中建议用更安全的 sigaction()）
    signal(SIGTERM, graceful_shutdown);
    
    // 注册 SIGINT (Ctrl+C) 也用同一个 handler
    signal(SIGINT, graceful_shutdown);
    
    // ⚠️ 以下代码会编译通过但不会生效——SIGKILL 不可捕获！
    // signal(SIGKILL, graceful_shutdown);  // 内核会忽略这个注册
    
    printf("进程 PID=%d 正在运行，等待信号...\n", getpid());
    
    // 模拟一个长时间运行的服务
    while (1) {
        sleep(1);   // 每秒循环一次，等待信号打断
    }
    
    return 0;   // 正常情况下不会到达这里
}

# 将编译任务放到后台执行
make -j8 &
# 输出: [1] 12345
#        ↑    ↑
#      作业号  PID
# Shell 立即返回提示符，可以继续输入其他命令
 
# 将下载任务放到后台
wget https://example.com/large_file.zip &
# [2] 12346

# 1. 查看当前 Shell 的所有后台作业
jobs
# 输出:
# [1]-  Running    make -j8 &
# [2]+  Running    wget https://example.com/large_file.zip &
#   +  表示"当前默认作业"（fg/bg 不指定编号时操作的对象）
#   -  表示"上一个作业"
 
# 加 -l 选项显示 PID
jobs -l
# [1]- 12345 Running    make -j8 &
# [2]+ 12346 Running    wget https://example.com/large_file.zip &
 
# 2. Ctrl+Z: 暂停前台进程，放入后台（状态变为 Stopped）
#    假设正在前台运行 vim:
#    按下 Ctrl+Z 后:
# [3]+  Stopped    vim notes.txt
#    vim 被暂停（SIGTSTP），终端控制权交还给 Shell
 
# 3. bg: 让暂停的作业在后台继续运行
bg %3          # %3 表示作业号为 3 的作业
# [3]+ vim notes.txt &    ← 注意：vim 这类需要终端交互的程序在后台运行没有意义
 
# 4. fg: 将后台作业调到前台
fg %1          # 将作业 [1] (make) 调到前台
#    此时终端被 make 占据，直到它完成或再次 Ctrl+Z
 
# 5. 快捷方式
fg             # 不指定编号 → 操作 "+" 标记的默认作业
bg             # 同上

# 场景：SSH 登录服务器，启动一个数据处理脚本
python3 process_data.py &
# [1] 54321
 
# 此时如果关闭 SSH 终端窗口...
# Shell 发送 SIGHUP 给 process_data.py
# → 进程被杀死！数据处理中断！

# nohup = No Hang Up，让进程免疫 SIGHUP 信号
# 标准用法：nohup 命令 &
nohup python3 process_data.py &
# 输出: nohup: ignoring input and appending output to 'nohup.out'
# [1] 54321
 
# nohup 做了三件事：
# 1. 将进程的 SIGHUP 信号处理设为 SIG_IGN（忽略）
# 2. 将 stdout 重定向到 nohup.out（如果当前目录不可写则重定向到 ~/nohup.out）
# 3. 将 stderr 也重定向到 stdout（即也写入 nohup.out）
 
# 自定义输出文件：
nohup python3 process_data.py > /var/log/myapp.log 2>&1 &
#                                ↑                  ↑   ↑
#                          stdout 重定向       stderr→stdout  后台运行
# 2>&1 的含义: 文件描述符 2(stderr) 重定向到文件描述符 1(stdout) 指向的位置
 
# 关闭终端后，进程继续运行。可以用 ps 或 top 查看
ps aux | grep process_data

# 如果你已经用 & 启动了进程，忘记加 nohup，可以事后补救
python3 long_task.py &
# [1] 54321
 
# 将作业从 Shell 的 job table 中移除
# Shell 不再跟踪该进程，关闭终端时不会向它发送 SIGHUP
disown %1
 
# 或者移除所有后台作业
disown -a
 
# 加 -h 选项: 仅标记为"不接收 SIGHUP"，但仍然保留在 jobs 列表中
disown -h %1

# 创建一个命名会话
tmux new -s mywork
# 进入 tmux 会话后，正常运行任何命令
python3 process_data.py
 
# 分离会话（Detach）: 按 Ctrl+B 松开后再按 D
# 回到原来的 Shell，tmux 会话在后台继续运行
 
# 查看所有 tmux 会话
tmux ls
# 输出: mywork: 1 windows (created Thu Feb 26 10:00:00 2026)
 
# 重新连接（Attach）
tmux attach -t mywork
# 回到之前的会话，进程还在运行
 
# SSH 断开重连后，仍然可以 attach 回去，一切如故

# ┌────────────┬───────────────┬────────────────┬──────────────────────────┐
# │ 特性        │ nohup &       │ disown         │ tmux / screen            │
# ├────────────┼───────────────┼────────────────┼──────────────────────────┤
# │ 终端关闭后   │ ✅ 存活       │ ✅ 存活        │ ✅ 存活                   │
# │ 能否重新交互 │ ❌ 不能       │ ❌ 不能        │ ✅ 可以 attach 回去       │
# │ 能否看输出   │ 📄 看日志文件 │ ❌ 输出丢失     │ ✅ 完整终端回放           │
# │ 使用时机     │ 启动时就知道   │ 忘记 nohup 时  │ 需要交互式长期任务        │
# │ 适合场景     │ 简单后台脚本   │ 事后补救       │ 开发/运维/调试（最推荐）   │
# └────────────┴───────────────┴────────────────┴──────────────────────────┘

# /etc/systemd/system/myapp.service
# 一个基本的 systemd 服务单元文件
[Unit]
Description=My Application Service    # 服务描述
After=network.target                  # 在网络服务启动后再启动
 
[Service]
Type=simple                           # 主进程就是服务进程
User=appuser                          # 以 appuser 身份运行（非 root）
WorkingDirectory=/opt/myapp           # 工作目录
ExecStart=/usr/bin/python3 /opt/myapp/main.py  # 启动命令
ExecStop=/bin/kill -TERM $MAINPID     # 停止时发送 SIGTERM
Restart=on-failure                    # 异常退出时自动重启
RestartSec=5                          # 重启间隔 5 秒
 
[Install]
WantedBy=multi-user.target            # 在多用户模式下启用
 
# 使用方式：
# systemctl daemon-reload      ← 重载 unit 文件
# systemctl start myapp        ← 启动服务
# systemctl stop myapp         ← 停止服务（发送 SIGTERM）
# systemctl restart myapp      ← 重启服务
# systemctl status myapp       ← 查看状态
# systemctl enable myapp       ← 设为开机自启
# journalctl -u myapp -f       ← 实时查看日志

python3 /opt/scripts/etl_job.py &

r = 4    w = 2    x = 1

# ========== 文件操作 ==========
ls -la              # 列出所有文件（含隐藏），显示详细信息
cd /etc             # 切换到 /etc 目录
pwd                 # 打印当前工作目录的绝对路径
mkdir -p a/b/c      # 递归创建多层目录
rm -rf dir/         # 强制递归删除目录（谨慎！）
 
# ========== 文本处理 ==========
cat file.txt        # 查看文件全部内容
grep -rn "error" .  # 在当前目录递归搜索包含 "error" 的行，显示行号
find / -name "*.log" -mtime -7   # 在根目录下查找 7 天内修改过的 .log 文件
 
# ========== 权限管理 ==========
chmod 755 script.sh        # 属主 rwx，属组 r-x，其他 r-x
chmod u+x,g-w file         # 属主加执行权，属组减写权
chown www-data:www-data /var/www  # 将目录归属改为 www-data 用户和组
 
# ========== 进程管理 ==========
ps aux | grep nginx         # 查看所有进程中包含 "nginx" 的条目
top -d 2                    # 每 2 秒刷新一次系统资源监控
kill -15 1234               # 向 PID 1234 发送 SIGTERM（温和终止）
kill -9 1234                # 向 PID 1234 发送 SIGKILL（强制终止）
nohup ./server &            # 后台运行 server，且终端关闭后不中断
jobs                        # 查看当前终端的后台任务列表
fg %1                       # 将 1 号后台任务切回前台

./long_task &