Skip to content

Linux 相关知识 ​


一、常用命令 ​

牛客高频词统计里「命令类」占比 24.63%,是所有 Linux 考点的第一名。

0. 先把练习环境搭起来(登进 SSH 先跑这一段) ​

后面所有带 🖥 的示例都在 ~/linux-lab 里跑,整段复制执行一次,之后每条命令都能亲眼看到输出:

bash
mkdir -p ~/linux-lab/logs ~/linux-lab/src ~/linux-lab/docs && cd ~/linux-lab

# ① 200 行类 nginx 日志:10.0.0.1 占 40%,另有 .2/.3/.4;状态码含 200/404/500
for i in $(seq 1 200); do
  case $((i % 10)) in
    0|1|2|3) ip=10.0.0.1 ;; 4|5) ip=10.0.0.2 ;; 6|7) ip=10.0.0.3 ;; *) ip=10.0.0.4 ;;
  esac
  case $((i % 11)) in 0) c=500 ;; 5) c=404 ;; *) c=200 ;; esac
  printf '%s - - [21/Sep/2026:10:%02d:%02d +0800] "GET /api/v%d HTTP/1.1" %d %d\n' \
    "$ip" $((i%60)) $((i%60)) $((i%5)) "$c" $((i*137%9000+100))
done > logs/access.log

# ② 时间戳不同的文件(练 find -mtime)
echo x > logs/app.log;      touch -d "3 days ago"  logs/app.log
echo x > logs/ancient.log;  touch -d "10 days ago" logs/ancient.log
# ③ 大小不一的文件(练 -size / du / df)
dd if=/dev/zero of=logs/big.bin bs=1M count=20 status=none
dd if=/dev/zero of=logs/mid.bin bs=1K count=500 status=none
# ④ 源码目录(练 grep -r / find -name)
printf '#include <iostream>\n// TODO: 优化这里\nint main(){}\n' > src/a.cpp
printf '// TODO: 加个日志\nvoid f(){}\n' > src/b.cpp
# ⑤ 名单 + 成绩表(练 sort/uniq/comm 与 awk 按列统计)
printf 'alice\nbob\ncarol\ndave\nbob\n' > docs/users_a.txt
printf 'bob\ndave\nerin\n'              > docs/users_b.txt
printf 'name,subject,score\nalice,math,92\nbob,math,78\ncarol,math,85\n' > docs/score.csv

1. find —— 按条件找文件 ​

find [路径] [条件] [动作]

条件说明
-name "*.log" / -iname按文件名(必须加引号,否则 shell 先展开)/ 忽略大小写
-type f/d/l普通文件 / 目录 / 软链接
-size +100M大于 100M(+ 大于、- 小于、无符号等于,单位 c/k/M/G)
-mtime -7 / +77 天内修改 / 7 天以前修改
-mmin -3030 分钟内
-maxdepth 2只往下 2 层,放最前面
-delete直接删除

高频题:-mtime -7 / +7 的区别? 以「天」为单位的滑动窗口,参照点是当前时间

find vs locate:locate 查数据库,秒级但可能过时(需 updatedb);find 实时遍历,慢但准。按名字找老文件用 locate,按属性(时间/大小)找用 find

🖥 动手试(先 cd ~/linux-lab):

bash
find . -name "*.log"                     # → ./logs/access.log、./logs/app.log 等 4 个
find . -type f -size +1M                 # → ./logs/big.bin(20M,唯一超过 1M 的)
find . -name "*.log" -mtime -7           # → 含 app.log(3 天前);ancient.log 不出现
find . -name "*.log" -mtime +7           # → 只剩 ./logs/ancient.log(10 天前)★ 对比上一条
find . -type f -printf '%s %p\n' | sort -rn | head -3   # 最大的 3 个文件(真题原型,见十一章)
find . -type f -mtime +7 -print          # 先 -print 确认名单,再换 -delete 真删

2. grep —— 按内容筛选 ​

参数作用
-i / -v忽略大小写 / 反向匹配(排除)
-n / -c显示行号 / 只输出匹配行数
-r / -l递归目录 / 只输出文件名
-w / -o全词匹配(-w is 不匹配 this)/ 只输出匹配到的部分
-A 3 / -B 3 / -C 3后 3 行 / 前 3 行 / 前后各 3 行

grep -C 1 实测:不同匹配块之间用 -- 分隔。

高频题:grep -r "TODO" . 和 find . -name "*.cpp" | xargs grep -n "TODO" 的区别?grep -r 递归所有文件(包括二进制、.git、日志),慢且刷乱码(需 -I 跳过二进制);find | xargs grep 可以先用 find 精筛类型/时间/大小再搜内容。按扩展名/时间过滤时必须用后者。

🖥 动手试(cd ~/linux-lab):

bash
grep -c " 404 " logs/access.log              # → 18(数有多少条 404;两侧空格避免匹配到字节数)
grep -v " 200 " logs/access.log | wc -l      # → 36(排除 200 后剩几行)
grep -n "10.0.0.2" logs/access.log | head -3 # 带行号,只看前 3 条
grep -rn "TODO" src/                         # 递归找代码里的待办 → 两个 .cpp 各一条
grep -rl "TODO" src/                         # -l 只回文件名,脚本里最好用
grep -C 1 " 500 " logs/access.log | head -7  # 前后各 1 行上下文,中间用 -- 分隔
grep -cE ' (5[0-9][0-9]) ' logs/access.log   # -E 正则:统计所有 5xx → 18
grep -o 'GET /api/v[0-9]' logs/access.log | sort | uniq -c | sort -rn
# ↑ -o 只输出匹配到的片段,这是「提取列」最省事的写法

3. sed —— 按行编辑 ​

sed [选项] '范围 动作' 文件

写法含义
sed 's/old/new/3' file每行第三个 old 替换为 new
sed 's/old/new/g' file每行所有 old 替换为 new
sed -n '5,8p' file只打印第 5~8 行(-n 抑制默认输出)
sed -i直接改原文件(不加 -i 只打印到屏幕,原文件不动)
sed -i.bak改前自动备份成 file.bak(生产脚本的保命习惯)

🖥 动手试(cd ~/linux-lab):

bash
sed -n '2,4p' logs/access.log          # 只看第 2~4 行
sed 's/200/OK/g' logs/access.log | head -2      # 替换后打到屏幕,原文件不动
sed -i.bak 's/TODO/DONE/' src/a.cpp             # ★ 真改文件,并留下 src/a.cpp.bak
sed '/^$/d' docs/users_a.txt                    # 删掉所有空行(^$ = 空行)
sed 's/$/ <-end/' docs/users_b.txt              # 每行行尾追加
sed 's/^/PREFIX: /' docs/users_b.txt            # 每行行首插入
sed -n '1p' logs/access.log | sed 's/ - -.*//'  # 链式:取第一行再砍掉 IP 后面的内容 → 10.0.0.1

-i 的坑:sed -i 会先写临时文件再改名,如果目标是软链接,改完软链接会变成普通文件;目标被别的进程占用时(可执行文件正在跑)还会报 Text file busy。所以线上改配置用 sed -i.bak 留个后路。

4. awk —— 按列处理 ​

awk -F分隔符 'BEGIN{} 条件{动作} END{}' 文件,逐行读入,切成 $1 $2 ... $NF。

内置变量含义
$0 / $1...$n整行 / 第 n 列(默认空白分隔)
$NF / $(NF-1)最后一列 / 倒数第二列(NF = 列数)
NR当前行号;FNR 当前文件内行号
FS / OFS输入 / 输出字段分隔符(-F: 按冒号切)
bash
awk '{print $1}' access.log                      # 取某列
awk '$9==500' access.log                         # 条件过滤
awk '$9>=400 && $9<600' access.log               # 4xx/5xx
awk '{sum+=$10} END{print sum, sum/NR}' access.log   # 求和/平均
awk '{cnt[$1]++} END{for (ip in cnt) print cnt[ip], ip}' access.log   # 分组计数
awk -F: '{print $1, $7}' /etc/passwd             # 处理 passwd

sed vs awk 的定位:sed 面向「行」,擅长增删改行和替换;awk 面向「列」,擅长按字段提取、过滤、统计。只做替换用 sed,一旦要按列算数就用 awk。

🖥 动手试(cd ~/linux-lab,每一条都是真题的雏形):

bash
awk '{print $1}' logs/access.log | sort | uniq -c | sort -rn
# ↑ 访问量 Top IP:80 / 40 / 40 / 40(10.0.0.1 最多)★ 最高频真题,见十一章题 1

awk '{print $9}' logs/access.log | sort | uniq -c | sort -rn
# ↑ 状态码分布 → 200:164、404:18、500:18

awk '{s += $10} END {print s}' logs/access.log     # 总响应字节数 → 910700
awk '{c[$9]++; t++} END {for (k in c) printf "%s: %.1f%%\n", k, c[k]*100/t}' logs/access.log
# ↑ 数组 + END 遍历 + printf 百分比,一把梭做出「状态码占比」

awk -F, 'NR>1 && $3 > 80 {print $1, $3}' docs/score.csv          # 条件筛选 → alice 92 / carol 85
awk -F, 'NR>1 && $3 > m {m = $3; who = $1} END {print who, m}' docs/score.csv   # 求最大值 → carol 95
awk -F, 'NR>1 {s[$2] += $3; n[$2]++} END {for (k in s) printf "%s 平均 %.1f\n", k, s[k]/n[k]}' docs/score.csv
# ↑ 分组求平均,这个「数组当哈希表」的写法能套掉一大半 awk 题

awk 'NR==1 || NR==3' docs/score.csv                # 按行号挑行
awk '{print NR"\t"$0}' docs/users_b.txt            # 加行号(等价 cat -n)

awk 心法:把 {} 想成「对每一行做的事」,END{} 是「所有行处理完后做的事」,数组 c[$9] 就是以字段值为 key 的哈希表。会了这一招,Top N / 分组统计 / 去重计数全是一个套路。

5. 管道、重定向与 xargs ​

写法含义
cmd > file / >> file覆盖 / 追加
cmd 2> file标准错误写入 f
cmd > file 2>&1stdout 和 stderr 都进 f
`cmdtee file`
`cmdxargs -I{} mv {} /tmp`
cmd > /dev/null 2>&1两个都丢弃(定时任务里常这么静音)

🖥 动手试(cd ~/linux-lab):

bash
du -sh * | sort -hr | head -3                    # 谁最占地方 → logs 21M
find . -type f | wc -l                           # 文件总数 → 12
ls -lh logs/ > /tmp/ls.txt && cat /tmp/ls.txt    # 重定向到文件再读
grep "404" logs/access.log > /dev/null; echo $?  # $? = 0 表示上一条命令成功
ls /no/such/dir 2>/dev/null || echo "命令失败了"  # 屏蔽刺眼的报错,只留自己的提示
find . -name "*.log" | xargs wc -l               # xargs 把结果当参数传给 wc
find . -name "*.log" -print0 | xargs -0 wc -l    # -print0/-0:文件名带空格也不会被拆错

2>&1 的位置有讲究:cmd > f 2>&1 ✅ 两个都进 f;cmd 2>&1 > f ❌ 只有 stdout 进 f,stderr 还是打到屏幕。因为重定向是从左到右生效的——先让 stderr 跟着当时的 stdout(还是终端),再把 stdout 改到文件。2>&1 必须写在 > file 后面。

6. 其他高频命令速查 ​

类别命令
文件ls -lh cp -r mv rm -rf touch file stat ln -s
查看cat less(/搜 G尾 q退)head -n 5 tail -n 5 tail -f wc -l diff
压缩tar -czvf a.tar.gz dir/ · tar -xzvf a.tar.gz · tar -tzvf 只看内容
系统uname -a df -h du -sh * free -h uptime date who

排序统计四件套(和 awk 并称「命令题半壁江山」,必须熟):

命令作用关键参数
sort排序-n 数字序(默认按字符串排,10 会排在 9 前面!)· -r 倒序 · -k3 按第 3 列 · -t, 指定分隔符 · -u 排序并去重
uniq只能处理相邻重复行-c 计数 · -d 只显示重复行 · -u 只显示不重复行
wc统计-l 行 · -w 单词 · -c 字节
cut按列切(只能按固定分隔符,不能按空白自动切)-d, 分隔符 · -f1,3 取第 1、3 列
tr字符替换/删除tr 'a-z' 'A-Z' 转大写 · tr -d '\r' 删 Windows 回车
tee分流| tee -a log.txt 一边上屏一边追加进文件
bash
sort -t, -k3 -rn docs/score.csv          # 按第 3 列(分数)数字倒序
sort docs/users_a.txt | uniq -c          # 每个名字出现几次
sort docs/users_a.txt | uniq -d          # 只列出重复的名字 → bob
echo "Hello" | tr 'a-z' 'A-Z'            # → HELLO
cut -d, -f1 docs/score.csv               # 按逗号切,取第 1 列

sort | uniq -c | sort -rn 是命令题的万能结尾。uniq 前面必须先 sort——它只比较相邻行,不排序直接 uniq 会把不相邻的重复行各算一次,这是最高频的失分点。


二、权限、用户与文件属性 ​

1. rwx 权限的本质 ​

-rwxr-xr-- 1 alice dev  1024 Sep 21 10:00 app.sh
│└┬┘└┬┘└┬┘   │     │
│ │  │  └── others:r--      文件类型:- 普通 d 目录 l 软链 c 字符设备 b 块设备
│ │  └───── group :r-x
│ └──────── owner :rwx
权限对文件对目录
r读取内容列出目录下文件名(ls)
w修改内容在目录内创建/删除/重命名文件
x执行进入目录(cd)、访问其下文件

高频题:目录的 x 权限为什么特殊?x 是「通行证」,r 只是「看名单」:

  • 只有 r 无 x:能 ls 看到文件名,但不能 cd,也读不到文件内容(ls -l 显示一堆 ?)。
  • 只有 x 无 r:能 cd、能访问已知路径的文件,但不列目录 —— 这正是「给特定文件授权但不给列表」的技巧。

高频题:删除文件需要什么权限?

看的是它所在目录的 w 权限,不是文件本身的权限。因为删除本质是修改目录项。这也解释了粘滞位为什么有用。

2. chmod / umask ​

bash
chmod 755 app.sh              # 数字法:rwxr-xr-x
chmod u+x,g-w,o=r app.sh      # 符号法
chmod -R 750 dir/             # 递归

r=4 w=2 x=1。644 普通文件默认 · 755 可执行/目录 · 600 只有自己能读写(私钥)· 777 全开(生产别用)。

umask:新建文件权限 = 基准 & ~umask。基准是文件 666、目录 777(文件默认不给 x)。 默认 umask 022 → 新文件 644、新目录 755;umask 077 → 600/700(私有项目常用)。

3. SUID / SGID / Sticky ​

位数值位置作用
SUID4000owner 的 x 位变 s执行时临时获得文件属主权限
SGID2000group 的 x 位变 s文件:执行获得属组权限;目录:新建文件继承目录属组
Sticky1000others 的 x 位变 t只有属主/目录属主/root 能删该目录下的文件
bash
-rwsr-xr-x  /usr/bin/passwd    # SUID:普通用户改密码要写 /etc/shadow
drwxrwxrwt  /tmp               # Sticky:所有人可写,但只能删自己的

4. 软链接 vs 硬链接(高频) ​

维度硬链接(ln a b)软链接(ln -s a b)
本质目录项指向同一 inode新 inode,内容是目标路径字符串
inode / 链接计数相同 / 增加 i_nlink不同 / 不影响
跨文件系统❌✅
链接目录❌(防环)✅
源文件删除后仍可用(数据在,直到计数归零)变断链
相对路径——相对于链接所在目录
bash
ls -li      # 硬链接两个名字 inode 相同
stat f      # Links 字段即硬链接数

答法模板:硬链接是「一个文件的多个名字」,共用 inode,删名字不删数据(计数归零才真删);软链接是「存路径的快捷方式」,源删即失效。跨文件系统、链目录、指向不存在的目标——这三点必须用软链接。

追问:为什么目录不能建硬链接? 会形成环,导致 find/fsck 无限递归;且现代文件系统靠硬链接数 > 1 判断目录有子目录。

5. 用户与组(速查) ​

文件内容
/etc/passwdname:x:UID:GID:注释:家目录:shell,所有人可读(密码位是占位 x)
/etc/shadow密码哈希,只有 root 可读(passwd 靠 SUID 写入)
/etc/group组名、GID、成员(一个用户一个主组 + 多个附加组)
bash
id / whoami                  # 身份
usermod -aG docker tom       # 追加附加组(-a 必须带,否则覆盖)
su - tom                     # 切用户(- 带环境变量)
sudo cmd                     # 以 root 执行

三、进程管理与 /proc ​

1. ps —— 静态快照 ​

两套风格别混用:ps aux(BSD,无 -,有 %CPU/%MEM)vs ps -ef(System V,有 -,有 PPID)。

问「怎么看进程的父进程」→ 答 ps -ef 或 ps -o ppid=。

bash
ps aux | grep [n]ginx            # 技巧:方括号让 grep 不匹配自己
ps -ef --forest                  # 树状父子关系
ps -eo pid,ppid,stat,cmd         # 自定义列
ps -T -p 1234                    # 看进程的线程
ps -mp 1234 -o THREAD,tid,time   # 线程级 CPU 占用

追问:ps aux | grep xxx 为什么会多一行? grep 自己是进程且命令行含 xxx。规避:grep [x]xx、grep -v grep、或 pgrep xxx。

2. top ​

bash
top              # 默认 3 秒刷新
top -H -p 1234   # 关键:只看某进程的「线程」,排查线程热点必用

交互键:P 按 CPU 排序 · M 按内存 · 1 展开每核 · H 线程视图 · c 完整命令行 · k 杀进程。

load average(1/5/15 分钟平均负载,含运行中 + **不可中断(D)**的进程数)。判断标准是除以 CPU 核数:4 核 load=4.0 表示刚好跑满,长期大于核数说明有排队。

进程状态 STAT(必背):

状态含义备注
RRunning / Runnable在跑或等 CPU
S可中断睡眠等事件(sleep/poll),最常见
D不可中断睡眠等磁盘 I/O,kill -9 也杀不掉
T停止SIGSTOP / Ctrl+Z
Z僵尸已退出但父进程没 wait
I空闲内核线程
< N s l +高优先级 / 低优先级 / 会话首进程 / 多线程 / 前台进程组附加标志

高频题:D 状态为什么 kill -9 杀不掉?D 是进程在内核态等待 I/O 完成,此时不响应任何信号——信号要回到用户态才处理,而它卡在内核里出不来。解法是解决底层 I/O(磁盘/NFS)或重启。load 高但 CPU 空闲时,问题往往在磁盘。

僵尸进程怎么找:ps aux | awk '$8 ~ /^Z/' 或 ps -ef | grep defunct(成因与处理见 5. 操作系统.md)。

3. kill 与信号 ​

bash
kill -l                      # 列出所有信号
kill -15 PID / kill PID      # SIGTERM,默认,优雅退出(可捕获、可清理)
kill -9 PID                  # SIGKILL,强杀,不可捕获/忽略
kill -1 PID                  # SIGHUP,常让服务重载配置
kill -3 PID                  # SIGQUIT,JVM 里打线程栈
pkill -f "python app.py"     # 按完整命令行匹配
SIGTERM(15)SIGKILL(9)
能否捕获/忽略/阻塞✅ 都可以❌ 都不行
行为通知「请退出」,程序自己决定内核直接回收,无清理机会

最佳实践:先 kill -15 给程序清理现场的机会(关连接、刷盘、释放锁),几秒不退再 -9。一上来就 -9 会导致数据没落盘、共享内存/信号量没释放、持锁让人死等。

4. 守护进程与后台运行 ​

bash
./app &          # 后台,但仍是当前 shell 子进程,关终端可能被 SIGHUP 带走
nohup ./app &    # 忽略 SIGHUP,输出到 nohup.out
setsid ./app     # 新会话,彻底脱离终端

守护进程(daemon)编写步骤(代码见第九章):fork() 后父进程退出 → setsid() 创建新会话 → (可选)再 fork() → chdir("/") → umask(0) → close(0/1/2) 重定向到 /dev/null。

生产上更推荐 systemd 托管(第十章),自带重启、日志、依赖管理,比裸 nohup 靠谱。

5. /proc —— 内核暴露的窗口 ​

虚拟文件系统,不占磁盘,读它就是在问内核要数据。「不装工具怎么查进程信息」的答案。

路径内容
/proc/PID/status状态、内存、线程数
/proc/PID/fd/该进程打开的所有 fd(软链到实际文件)—— 排查「文件被谁占用」的金矿
/proc/PID/cmdline / environ启动命令 / 环境变量
/proc/PID/maps内存映射(哪个库映射到哪段地址)
/proc/PID/limits资源限制(等价 ulimit -a)
/proc/cpuinfo / meminfo / loadavgCPU / 内存 / 负载(nproc、uptime 的来源)
/proc/sys/可写的内核参数(core_pattern、vm.swappiness)

6. 优先级(速查) ​

nice -n 10 ./app 启动时设 · renice -n 5 -p 1234 调整。范围 -20~19,越小优先级越高。普通用户只能调低(让出 CPU),只有 root 能设负值。


四、网络排查 ​

C++ 后端场景题主战场:「服务起不来」「端口被占用」「连不上」。

1. ss / netstat ​

ss 是现代替代品,直接读内核 netlink,比 netstat 快得多。新系统默认不装 netstat。

bash
ss -tunlp                      # 最常用:TCP+UDP,-n 不解析,-l 只看 LISTEN,-p 显示进程
ss -tan state established      # 只看已建立连接
ss -s                          # 汇总统计
netstat -anp | grep 8080       # 老写法

参数:-t/-u TCP/UDP · -l LISTEN · -a 全部 · -n 不解析(排查必加,否则 DNS 反查会卡)· -p 显示进程。

状态含义
LISTEN服务端在监听
ESTABLISHED连接已建立
TIME_WAIT主动关闭方等待 2MSL
CLOSE_WAIT被动关闭方收到 FIN 但还没 close —— 代码 bug 信号
SYN_RECV半连接(可能被 SYN Flood)

大量 CLOSE_WAIT = 我们的程序收到对方 FIN 后没调 close()(fd 泄漏)。这是排查泄露的第一线索。

2. 端口占用排查(超高频) ​

bash
ss -tunlp | grep 8080
netstat -tunlp | grep 8080
lsof -i :8080                  # 更准,直接问「谁打开了这个端口」

⚠️ netstat -anp | grep 8080 会匹配到「连到该端口的客户端连接」。只有状态是 LISTEN 的那行才是真正占用端口的服务。容易被抠这个。

3. lsof 与 tcpdump ​

bash
lsof -i :8080        # 谁占用端口
lsof -p 1234         # 进程打开了什么
lsof /var/log/app.log    # 谁在用这个文件
lsof +L1             # 链接数为 0 的文件(=已删除但被占用,见第五章)

tcpdump -i eth0 -nn port 8080                      # 抓端口
tcpdump -i any -nn -w /tmp/cap.pcap 'tcp port 80'  # 存文件,本地用 wireshark 分析
tcpdump -i eth0 -nn -A 'tcp port 80'               # -A 以 ASCII 打印(看 HTTP 明文)

-nn 不解析主机名/端口名(必加);-w 写文件,生产优先 -w 避免在服务器上解析;需 root;流量大时 tcpdump 本身会成瓶颈。

4. 「连不上/服务起不来」排查套路(背这个) ​

bash
ping -c 3 10.0.0.5            # 1. 网络层通不通(可能被防火墙禁 ICMP)
nc -zv 10.0.0.5 8080          # 2. 端口通不通
curl -v http://10.0.0.5:8080/ # 3. 应用层通不通
traceroute 10.0.0.5           # 4. 路由在哪跳断
dig example.com               # 5. DNS

顺序化排查链:

  1. 进程还在吗:ps aux | grep 服务名 —— 挂了先看日志
  2. 端口在听吗:ss -tunlp | grep 端口 —— 没 LISTEN 说明没起来或绑错端口
  3. 本机通吗:curl 127.0.0.1:端口 —— 本机不通是服务问题
  4. 外部通吗:nc -zv IP 端口 —— 本机通外部不通 → 防火墙 / 安全组 / 监听地址写成了 127.0.0.1
  5. 看日志:tail -F app.log、journalctl -u 服务 -n 100、dmesg | tail(被 OOM Killer 杀了会在这)

第 4 步那个坑极高频:服务 bind(127.0.0.1:8080) 时只能本机访问,外部连不上但本机 curl 正常。标准答案就是查监听地址和防火墙。


五、磁盘、文件系统与空间排查 ​

1. df / du ​

bash
df -h              # 各挂载点已用/总量
df -i              # inode 使用率(关键)
du -sh *           # 当前目录下各子项大小
du -h --max-depth=1 /var | sort -hr | head    # 找哪个子目录最占地方
dfdu
视角文件系统(超级块统计)文件(逐个遍历累加)
速度快慢

2. inode ​

inode 存文件的元数据(权限、属主、大小、时间戳、数据块指针),不含文件名。文件名存在目录项里,目录项把「名字」映射到「inode 号」。

目录项 ("app.log" → inode 1314521) ──→ inode(权限/时间/大小) ──→ 数据块

这解释了两件事:硬链接是两个目录项指向同一 inode;删除文件删的是目录项,inode 和数据的释放要看链接计数归零 + 无进程打开。

inode 耗尽:大量小文件。inode 数在 mkfs 时固定,df -h 空间充足但创建不了新文件就是它。

bash
df -i                                  # 确认是否 100%
for d in /var/*; do echo "$(find $d -type f 2>/dev/null | wc -l) $d"; done | sort -rn | head

典型元凶:/var/spool/postfix/maildrop、会话文件、没清理的临时文件。

3. 磁盘满了但 df 和 du 对不上(超高频场景题) ​

现象:df -h 显示 100%,但 du -sh / 加起来只有一半。

原因:某个大文件被 rm 了(目录项没了,du 看不到),但还有进程开着它的 fd(inode 引用计数不为 0,数据块没释放),df 一直在统计它。

bash
lsof +L1                  # 列出链接数为 0 但仍被打开的文件
lsof | grep deleted       # 同上

处理:重启或 kill 持有该 fd 的进程;更优雅的是让进程重新打开日志——> /proc/PID/fd/N 或发信号让它 reopen(kill -USR1)。

答题思路:df 和 du 不一致的经典原因是「文件被删但被进程占用」,用 lsof +L1 找,重启进程或让它重开文件即可。这也是**日志切割必须配合「通知进程 reopen」**的原因——直接 rm 日志是最典型的踩坑姿势。

4. 磁盘 I/O 排查 ​

bash
iostat -x 1 5      # 扩展统计,每秒一次共 5 次
iotop              # 按进程看 I/O(需 root)

iostat -x 关键列:%util(设备忙碌百分比,接近 100% 说明磁盘是瓶颈)· await(平均 I/O 等待,含排队)· r/s w/s(IOPS)· rkB/s wkB/s(吞吐)。

联动:top 里大量 D 状态 + load 很高但 CPU 空闲 → 八成是磁盘 I/O 打满。这条**「高 load + 低 CPU = 等 I/O」**的排查链很受用。

5. 挂载(速查) ​

lsblk 块设备树 · mount | column -t · mount /dev/sdb1 /mnt · umount /mnt(提示 busy 说明有进程在用,用 lsof 查)· /etc/fstab 开机挂载。

小问:为什么挂载后原目录下的文件「消失」了? 挂载是用新文件系统的根覆盖了挂载点的目录项,原内容还在原设备的 inode 上,umount 后又能看到。所以不要把服务目录挂到已有数据的目录上。


六、gdb 调试与 core dump ​

C++ 岗硬通货。问法通常是「线上服务崩了没日志,你怎么定位」——答案必须是 core dump + gdb。

1. 编译准备 ​

bash
g++ -g -O0 app.cpp -o app      # -g 调试信息,-O0 关优化

坑:-O2 下断点会跳、变量显示 <optimized out>、函数被内联导致 bt 栈帧缺失。复现 bug 用 -O0 -g,线上 core 要用带 -g 编译的版本(或配合 debuginfo 包)。

2. 常用命令(必须背) ​

启动:gdb ./app · gdb ./app core.1234(分析 core)· gdb -p 1234(attach 卡死进程)

断点:

命令作用
b main / b file.cpp:42函数断点 / 行断点
b func if x>10条件断点(避免停一百次)
tbreak / rbreak regex临时断点(命中一次即删)/ 正则批量下断
watch var观察点:变量被写时停下(「谁改了我的变量」神器)
catch throw / catch syscall open捕获异常抛出 / 系统调用
info breakpoints / delete 2 / disable 2查看 / 删除 / 禁用

运行:run(r) · continue(c) · next(n) 跳过函数 / step(s) 进入函数 · finish(执行到函数返回,看返回值)· until 42(跳出循环)· return value

查看:

命令作用
bt / bt full打印调用栈(core 分析第一命令)/ 带局部变量
frame 3(f 3)/ up / down切栈帧
p var / p *ptr / p arr[2]@5打印变量 / 解引用 / 打印数组 5 个元素
p/x p/d p/s十六进制 / 十进制 / 字符串
info locals / info args / info registers局部变量 / 参数 / 寄存器(崩溃看 rip、rsp)
x/10gx ptr按内存查看:10 个 8 字节十六进制(gx=8字节,wx=4字节,s=字符串)
list(l) / disas源码 / 反汇编

多线程(排查卡死/死锁必备):

bash
info threads                     # 列出所有线程
thread 3                         # 切到线程 3
thread apply all bt              # 所有线程的调用栈(死锁排查第一招)
thread apply all bt full         # 带局部变量,看谁持锁

3. 实战:段错误定位流程 ​

bash
ulimit -c unlimited      # 1. 生成 core
./app                    # 崩溃 → core.PID
gdb ./app core.PID       # 2. 分析
(gdb) bt
# #0  0x00005555555551a9 in Node::next (this=0x0) at list.cpp:15   ← 罪魁祸首
# #1  0x00005555555551d4 in main () at main.cpp:9                   ← 调用者
(gdb) f 0
(gdb) info locals
(gdb) p this             # $1 = (Node *) 0x0    ← 空指针实锤

答法模板:段错误就是访问了非法地址。先 bt 找崩溃的那一帧(#0),看 this/指针是不是 0x0 或野值;再看 #1 是谁传进来的。常见原因:空指针、野指针(对象已析构)、数组越界、栈溢出(递归太深)。

4. core dump 配置 ​

bash
ulimit -c unlimited                              # 当前 shell(默认常常是 0,即不生成)
cat /proc/sys/kernel/core_pattern                # core 文件命名/去向
sysctl -w kernel.core_pattern=/var/core/core.%e.%p.%t

占位符:%e 可执行文件名 · %p PID · %t 时间戳 · %s 信号 · %u 用户。

两种配置:文件名模板(内核直接写文件)或管道(以 | 开头,内核把 core 交给一个程序处理,Apport / systemd-coredump 都这么干)。

你当前 WSL2 环境的真实配置:

bash
$ ulimit -c
0                                  # ← 默认不生成 core!调试前必须先改
$ cat /proc/sys/kernel/core_pattern
|/wsl-capture-crash %t %E %p %s    # ← 管道模式

延伸:core 为什么不生成? ① ulimit -c 为 0;② pattern 目录不存在/无权限;③ 磁盘满;④ 程序自己 setrlimit 关了;⑤ 崩在容器里且没挂载对应目录(容器内排查的经典坑)。

5. gdb 的原理 —— ptrace ​

靠内核的 ptrace 系统调用:PTRACE_ATTACH(attach 并暂停目标)· PEEKTEXT/POKETEXT(读写内存)· GETREGS/SETREGS(读写寄存器)· SINGLESTEP(单步)· CONT(继续)。

断点原理(高频):gdb 把目标地址的指令首字节替换成 0xCC(int3 软中断)。CPU 执行到 0xCC 触发陷阱 → 控制权交 gdb → 恢复原指令、暂停给用户看。继续时再写回 0xCC。

由此可推:① 断点多了会变慢;② 0xCC 写在代码段,gdb 依赖 mprotect 把代码段改成可写——这也是某些反调试手段检测 gdb 的思路。


七、性能分析与问题定位 ​

综合场景题:「CPU 100% 怎么查」「内存一直涨怎么查」。答题关键是给出有顺序的排查链路,不是罗列工具。

1. 万能排查模型:自顶向下(背这个框架) ​

① 看全局    top / free / df / iostat -x    → 定位是 CPU、内存、磁盘还是网络
② 定位进程  top 排序 → 找到 PID
③ 定位线程  top -H -p PID / ps -T -p PID
④ 定位函数  perf top -p PID / perf record + report
⑤ 定位系统调用  strace -p TID -T -tt
⑥ 看栈      pstack PID / gdb -p PID → thread apply all bt
⑦ 看内核    dmesg | tail(OOM、硬件报错)、/proc/PID/status

2. CPU 使用率过高 ​

bash
# ① 找进程
top -c                      # 按 P 排序,记 PID
ps aux --sort=-%cpu | head

# ② 找线程(关键一步,多线程程序必须做)
top -H -p 1234
printf '%x\n' TID           # 线程 ID 转十六进制(perf/gdb 要)

# ③ 看这个线程在干什么
perf top -p 1234                                    # 实时看热点函数
perf record -p 1234 -g -- sleep 30 && perf report   # 采样 30 秒再离线分析
strace -p 1234 -c                                   # 统计系统调用耗时
pstack 1234                                         # 打线程栈

分四种情况判断根因(加分点):

现象根因
用户态 CPU 高,perf top 有热点业务代码问题(死循环、算法复杂度、频繁拷贝)
系统态 CPU 高(sy 高)系统调用太频繁(小 I/O、锁竞争、上下文切换),用 strace -c
CPU 不高但负载高、大量 D 状态等磁盘 I/O,看 iostat -x
用户进程都正常但整体 CPU 高内核线程、软中断(/proc/softirqs)、被挖矿

3. 内存问题 ​

bash
free -h                            # 全局
ps aux --sort=-%mem | head         # 找进程(看 RSS)
cat /proc/PID/status | grep VmRSS  # RSS=实际物理内存,VmSize=虚拟
valgrind --leak-check=full ./app   # 离线最准,但慢 20~100 倍
g++ -g -fsanitize=address -fno-omit-frame-pointer app.cpp   # ASan(查越界/泄漏/UAF)
g++ -g -fsanitize=thread app.cpp                            # TSan(查数据竞争)
dmesg | grep -i "out of memory"    # 看 OOM Killer 杀了谁

区分「真泄漏」和「假泄漏」(重要):

  • 真泄漏:丢了指针,内存永远无法释放 → valgrind/ASan 确认
  • 假泄漏:glibc 的 malloc 用 brk 扩堆后不一定归还操作系统(free 只是还到空闲链表);mmap 阈值 128KB 以上的大块才直接还。RSS 高但稳定 = 正常。

判断方法:while true; do grep VmRSS /proc/PID/status; sleep 5; done —— 持续单调上涨才是泄漏,涨到平台期不用慌。

4. strace / ltrace ​

bash
strace ./app                       # 跟踪所有系统调用
strace -p 1234                     # attach
strace -f ./app                    # 跟踪子进程/线程(重要)
strace -c ./app                    # 统计每个系统调用的次数、耗时、错误
strace -T -tt ./app                # 每行加时间戳 + 调用耗时
strace -e trace=network -p 1234    # 只跟网络相关
strace -o out.log ./app            # 输出到文件(量大必备)
ltrace ./app                       # 跟踪库函数(malloc/strlen),层次更高

输出解读:

openat(AT_FDCWD, "/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
connect(3, {sa_family=AF_INET, sin_port=htons(8080)}, 16) = -1 ECONNREFUSED   ← 连接被拒
  • 返回值 -1 + errno 是排查重点(ENOENT 文件不存在、ECONNREFUSED 拒绝、EAGAIN 非阻塞无数据)
  • 只显示 openat 不显示 open:glibc 的 open 是弱符号,最终走 openat(AT_FDCWD, ...)

生产注意(高频加分点):strace 会让目标进程性能下降 10~100 倍,绝不能在线上长期挂着。要短时、过滤、输出到文件。输出可能含密码/密钥,文件权限要 chmod 600。可用 kernel.yama.ptrace_scope=1 限制非 root ptrace。

5. perf ​

bash
perf top                                  # 函数级热点(全系统)
perf top -p 1234                          # 只看某进程
perf stat ./app                           # IPC、cache-miss、分支预测失败
perf stat -e cache-misses,cache-references ./app
perf record -g ./app && perf report       # 采样 + 调用图
perf record -p 1234 -g -- sleep 30        # 对运行中进程采 30 秒

关键指标:IPC(每周期指令数,>1 好,<0.5 说明常在等内存)· cache-misses(命中率低考虑数据结构布局/伪共享)· branch-misses(高则考虑去虚函数/去分支)。

perf vs strace:perf 是统计采样、开销低,看「时间花在哪个函数」;strace 是精确跟踪、开销大,看「做了哪些系统调用、参数对不对」。调性能用 perf,查错误/找 I/O 问题用 strace。

6. 工具对比总表(直接背) ​

工具跟踪对象用途开销场景
top/htop进程/线程全局概览低第一眼
perf硬件/软件事件函数级热点低性能优化
strace系统调用I/O、网络、文件高(10~100×)功能调试、报错
ltrace库函数库调用高库层调试
gdb/pstack进程/线程/内存崩溃、死锁、看栈中(暂停进程)崩溃/卡死
valgrind内存访问泄漏、越界、UAF极高(20~100×)离线测试
ASan/TSan编译插桩内存/竞态中(2~3×)测试期常开
tcpdump网络包协议层问题中网络排查

「线程卡死/死锁」:gdb -p PID → thread apply all bt → 看是否多个线程停在 pthread_mutex_lock,且各自持有对方要的锁。或 pstack PID 直接出栈。


八、编译链接与构建 ​

C++ 岗特色。高频:「编译到运行经历了什么」「静态库和动态库的区别」「Makefile 怎么写」。答得清楚说明你真在 Linux 上写过程序。

1. 编译四阶段(必背) ​

阶段命令输入 → 输出做什么
预处理g++ -E a.cpp -o a.i.cpp/.h → .i展开 #include、宏替换、去注释
编译g++ -S a.i -o a.s.i → .s语法分析、优化、生成汇编
汇编g++ -c a.s -o a.o.s → .o转机器码,生成 ELF 目标文件
链接g++ a.o -o app.o + 库 → 可执行符号解析 + 重定位

本机实测:8 行源码预处理后变成 1052 行(全是头文件);file hello.o 显示 ELF ... relocatable(可重定位,地址未定);最终可执行是 pie executable, dynamically linked。

追问:链接器做了什么? ① 符号解析:把每个 .o 里的未定义符号(U)在别的 .o 或库里找到定义(T/D/B);② 重定位:把符号最终地址填回指令占位处。找不到 → undefined reference to xxx;找到多个 → multiple definition of xxx。

-pie 是什么:位置无关可执行文件,配合 ASLR 每次加载到随机地址(安全加固)。-no-pie 可关(调试时地址固定更方便)。

2. gcc/g++ 常用选项 ​

选项作用
-I dir加头文件搜索路径(大写 I)
-L dir加库文件搜索路径(大写 L)
-l name链接 libname.so/libname.a(小写 l,顺序敏感)
-D MACRO=1命令行定义宏
-O0/-O1/-O2/-O3/-Os优化级别(-O2 生产常用)
-g / -g3调试信息
-Wall -Wextra / -Werror打开警告(必加)/ 警告当错误
-std=c++17标准版本
-fPIC位置无关代码(做动态库必须)
-shared / -static动态库 / 全静态
-pthread启用线程库(编译和链接都要加)

-l 的顺序坑:链接器从左到右扫描,遇到未解析符号才去后面找。所以 g++ main.o -lmath 对,-lmath 放前面可能报 undefined reference。库之间有依赖时,被依赖的放后面。

3. 静态库 vs 动态库(超高频) ​

维度静态库 .a动态库 .so
生成g++ -c a.cpp b.cpp
ar rcs libmath.a a.o b.o
g++ -fPIC -shared a.cpp b.cpp -o libmath.so
链接时机编译期,代码复制进可执行文件运行期,由 ld.so 动态加载
体积大(本机实测:静态 767K vs 动态 16K)小
内存共享❌ 每个进程一份✅ 多进程共享同一份物理内存
更新库❌ 必须重编程序✅ 替换 .so 即可
部署✅ 拷过去就能跑❌ 目标机要有对应版本的库

追问:-fPIC 为什么必须加? PIC = 位置无关代码。动态库加载到哪是运行时决定的,不能用绝对地址寻址,要用 GOT(全局偏移表)+ PLT(过程链接表) 间接跳转。不加会报 relocation R_X86_64_32S ... recompile with -fPIC。

追问:.a 和 .so 同名时链接谁? 默认优先 .so(-static 或 -Wl,-Bstatic 才用 .a)。

4. 运行时怎么找到 .so(高频,实测踩坑) ​

bash
$ g++ main.cpp -L. -lmath -o app_dyn     # 编译链接都成功
$ LD_LIBRARY_PATH=. ./app_dyn
3 12                                      # ✓ 能跑
$ ./app_dyn
./app_dyn: error while loading shared libraries:
           libmath.so: cannot open shared object file: No such file or directory

解释:编译期的 -L. 只影响链接阶段;运行时由 ld.so 按另一套规则找。

运行期查找顺序:① DT_RPATH → ② LD_LIBRARY_PATH → ③ DT_RUNPATH(-Wl,-rpath)→ ④ /etc/ld.so.cache(/etc/ld.so.conf + ldconfig)→ ⑤ /lib、/usr/lib

bash
LD_LIBRARY_PATH=/opt/mylib ./app         # 临时(常用,但别写进生产脚本)
sudo ldconfig                            # 刷新 cache
echo /opt/mylib | sudo tee /etc/ld.so.conf.d/mylib.conf && sudo ldconfig   # 永久
g++ main.cpp -L. -lmath -Wl,-rpath,'$ORIGIN' -o app    # 编译期写死相对路径(推荐)
ldd ./app                                # 检查依赖是否都能找到

$ORIGIN 是运行时展开的「可执行文件所在目录」,让程序和 .so 一起打包,换台机器也能跑,比 LD_LIBRARY_PATH 干净。发布 C++ 服务的标准做法。

LD_PRELOAD=/path/libhook.so ./app 可在程序启动前抢先加载某个库,hook malloc/open 等函数做监控、注入、打桩 —— 这是内存检测工具(tcmalloc/jemalloc)的原理,也是安全风险(可劫持任意函数),所以 SUID 程序会忽略它。

5. 二进制工具四件套 ​

工具用途常用命令
nm看符号表nm -C app(-C 反解 C++ 名字修饰)
objdump反汇编、看段objdump -d app / -t(符号)/ -h(段头)
readelf看 ELF 结构readelf -h / -S(段表)/ -d(动态段)/ -s(符号)
ldd看动态依赖ldd ./app
strings / file提取字符串 / 判断类型strings app | grep -i version

nm 符号类型字母:T/t 代码段(全局/局部)· D/d 已初始化数据(.data)· B/b 未初始化(.bss)· R/r 只读(.rodata)· U 未定义(需链接别的库)· W/w 弱符号。

本机实测:nm -C hello.o → T main + U puts;nm -C --defined-only libmath.so → T add(int, int)、T mul(int, int)。

6. Makefile ​

核心规则:目标: 依赖 换行后 TAB 缩进的命令(必须是 Tab,不能用空格——新手最经典的坑)。

makefile
CXX      := g++
CXXFLAGS := -std=c++17 -Wall -O2 -g
TARGET   := app
SRCS     := $(wildcard *.cpp)
OBJS     := $(SRCS:.cpp=.o)

$(TARGET): $(OBJS)
	$(CXX) $(CXXFLAGS) -o $@ $^

%.o: %.cpp
	$(CXX) $(CXXFLAGS) -c $< -o $@

-include $(OBJS:.o=.d)          # 头文件依赖,改头文件能触发重编

.PHONY: clean                   # 伪目标:不对应文件,必须声明
clean:
	rm -f $(OBJS) $(TARGET)

自动变量:$@ 目标 · $< 第一个依赖 · $^ 所有依赖 · $? 比目标新的依赖。 变量赋值:= 递归展开 · := 立即展开(推荐)· ?= 未定义才赋值 · += 追加。

常问:「改了头文件为什么没重新编译?」 传统 Makefile 只写了 .o: .cpp,没写头文件依赖。解法是 g++ -MM 生成 .d 再 -include 进来。

默认行为:不带参数执行第一个目标(所以 all 通常放最前);make -j8 并行;make -n 只打印不执行。

7. CMake(现代 C++ 标配) ​

cmake
cmake_minimum_required(VERSION 3.15)
project(myapp CXX)
set(CMAKE_CXX_STANDARD 17)

add_executable(app main.cpp src/list.cpp)
target_include_directories(app PRIVATE include)
target_link_libraries(app PRIVATE Threads::Threads)   # 现代写法:用 target_ 系列,传递依赖
find_package(Threads REQUIRED)

add_library(mymath SHARED math.cpp)      # STATIC 则生成 .a
bash
cmake -S . -B build -DCMAKE_BUILD_TYPE=Release   # 配置(out-of-source,规范做法)
cmake --build build -j8                          # 编译

CMAKE_BUILD_TYPE:Debug(-g -O0)· Release(-O3 -DNDEBUG)· RelWithDebInfo(-O2 -g,线上推荐)。

cmake vs make:make 是构建工具(描述「怎么编译」),cmake 是构建系统生成器(描述「项目结构」,再生成 Makefile/Ninja/Xcode 工程)。答清这层关系就够。

8. 交叉编译(机器人方向必问) ​

概念:在 x86 开发机上编译出能在 ARM 目标板(树莓派、Jetson、瑞芯微)运行的代码。因为目标板算力弱跑不动编译器。

bash
aarch64-linux-gnu-g++ main.cpp -o app_arm     # 工具链命名:架构-厂商-OS-ABI
cmake -S . -B build-arm -DCMAKE_TOOLCHAIN_FILE=arm.cmake
cmake
# arm.cmake
set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_PROCESSOR aarch64)
set(CMAKE_C_COMPILER   aarch64-linux-gnu-gcc)
set(CMAKE_CXX_COMPILER aarch64-linux-gnu-g++)
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)   # 程序在 host 找
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)    # 库在 target 找
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

配套的坑:所有依赖库也必须是交叉编译出的 ARM 版本(链 x86 的 .so 会报 wrong ELF class)。所以常用 Buildroot / Yocto / ROS2 colcon 批量交叉编译整个依赖树。


九、系统编程 API(速查) ​

5. 操作系统.md 讲原理,这里讲调用。

1. 文件 I/O:系统调用 vs 标准库 ​

系统调用(无缓冲)标准库(有缓冲)
接口open read write close lseekfopen fread fwrite fclose
对象文件描述符 fd(int)文件流 FILE*
适合大文件、网络、精确控制小块读写、格式化 I/O

三种缓冲:全缓冲(文件,满才写)· 行缓冲(终端,遇 \n 刷新)· 无缓冲(stderr,立即输出)。

经典题:printf 之后 fork 会重复输出

c
printf("hello");   // 缓冲区里还有 "hello"
fork();            // 子进程复制了用户态缓冲区 → 父子退出时各刷一次 → 打印两次

解法:加 \n、fflush(stdout)、或 setbuf(stdout, NULL)。

c
int fd = open("f.txt", O_RDWR | O_CREAT | O_TRUNC, 0644);   // 失败返回 -1 并设 errno
ssize_t n = read(fd, buf, sizeof(buf));   // 0=EOF,-1=出错

flag:O_APPEND(多进程写日志必加,保证原子)· O_EXCL(配合 O_CREAT 实现原子创建/文件锁)· O_NONBLOCK · O_DIRECT · O_SYNC

必考细节:

  • read/write 返回的可能小于请求字节数(信号中断、管道剩余不足),要写循环;errno == EINTR 时必须重试(否则偶发 bug)。
  • write 到管道/socket 时,小于 PIPE_BUF(4096) 的写是原子的。

2. fd 与 dup/dup2 ​

每个进程一张文件描述符表,表项指向系统级的打开文件表(含偏移量),再指向 inode。所以:fork 后父子共享同一个打开文件表项 → 共享偏移量;同一进程 dup 出的 fd 也共享偏移量。0/1/2 = stdin/stdout/stderr。

c
int newfd = dup2(oldfd, 1);   // 把 fd 1(stdout)指向 oldfd 的文件 —— 重定向核心

经典应用:dup2 实现重定向(shell 的 > 就是这个原理):

c
int fd = open("out.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
dup2(fd, STDOUT_FILENO);   // 之后所有 printf 都写进 out.txt
close(fd);

常问:close(1) 之后 open 一个文件会怎样? 新文件会拿到 fd 1,所有 printf 都写进这个文件 —— fd 泄漏 + 复用的经典诡异 bug。

3. 文件锁 ​

flock(整文件,BSD)vs fcntl(可按字节区间,POSIX)。都是建议锁 —— 只有大家都调用才起作用,不检查的进程照样能写(强制锁需挂载选项且已废弃)。

c
// 进程单实例
int fd = open("/var/run/app.lock", O_CREAT | O_RDWR, 0644);
if (flock(fd, LOCK_EX | LOCK_NB) == -1) { fprintf(stderr, "running\n"); exit(1); }

4. 进程控制 ​

c
pid_t pid = fork();          // 父返回子 PID,子返回 0,失败 -1
if (pid == 0) {
    execlp("ls", "ls", "-l", NULL);   // exec 家族:替换进程映像,成功不返回
    _exit(127);              // exec 失败才到这(用 _exit 不是 exit)
} else if (pid > 0) {
    int status; waitpid(pid, &status, 0);    // 不回收会变僵尸
    if (WIFEXITED(status))  printf("exit %d\n", WEXITSTATUS(status));
    if (WIFSIGNALED(status)) printf("killed by %d\n", WTERMSIG(status));
}

exec 后缀含义:l=参数列表 · v=参数数组 · p=用 PATH 查找 · e=指定环境变量。

exit vs _exit:exit 会刷 stdio 缓冲 + 调 atexit;_exit 直接进内核。fork 出的子进程通常用 _exit,避免父进程缓冲区被刷两遍。

system() vs fork+exec:system("ls -l") = fork + exec /bin/sh -c + waitpid,方便但会起 shell(注入风险、开销大)。生产代码用 fork+exec 自己拼参数。

5. 线程:pthread ​

c
pthread_create(&tid, NULL, worker, &arg);
pthread_join(tid, NULL);        // 不 join 且不 detach 会泄漏资源
pthread_detach(tid);            // 或分离,系统自动回收

编译要加 -pthread(不是 -lpthread,它会同时设置 _REENTRANT 宏)。

pthread_cond_wait 三个必考细节:

  1. 必须配 mutex,调用时原子地「释放锁 + 睡眠」,唤醒后重新拿锁
  2. 必须写 while 不是 if(防虚假唤醒)
  3. signal 只唤醒一个,broadcast 唤醒全部再各自判断
c
pthread_mutex_lock(&mtx);
while (queue_empty()) {                 // 必须 while!
    pthread_cond_wait(&cond, &mtx);
}
item = pop();
pthread_mutex_unlock(&mtx);

线程池完整实现见 源码整理/1.线程池.cpp;C++ 层面 std::condition_variable 同理。

6. IPC 速查 ​

方式API特点
匿名管道pipe(int fd[2])只能亲缘进程,单向
命名管道mkfifo任意进程,走文件系统
共享内存shmget/shmat(SysV)
shm_open+mmap(POSIX)
最快(零拷贝),需自己做同步
消息队列msgget/msgsnd/msgrcv有边界消息
信号量sem_wait/sem_post同步用,不传数据
socketsocket...唯一能跨主机;Unix domain socket 本机高性能 IPC

共享内存为什么最快:数据只拷贝一次(写进共享区),双方直接读写同一块物理内存,没有内核缓冲区中转。代价是要自己同步,否则读到脏数据。

mmap 的其他用途:① 大文件读写(按需加载,靠缺页中断);② MAP_ANONYMOUS|MAP_PRIVATE 替代 malloc(malloc 大块内存底层就是它);③ 进程间共享;④ 加载动态库(ld.so 就是 mmap 把 .so 映射进来的)。

7. socket 编程流程(必背) ​

TCP 服务端:

c
int lfd = socket(AF_INET, SOCK_STREAM, 0);
int opt = 1; setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));  // 重启不报 Address already in use
struct sockaddr_in addr = {0};
addr.sin_family = AF_INET;
addr.sin_port = htons(8080);               // 端口转网络字节序
addr.sin_addr.s_addr = htonl(INADDR_ANY);  // 0.0.0.0 监听所有网卡(写 127.0.0.1 就只能本机访问!)
bind(lfd, (struct sockaddr*)&addr, sizeof(addr));
listen(lfd, 128);                          // 128 是已完成连接队列上限,不是连接数上限
for (;;) { int cfd = accept(lfd, NULL, NULL); /* 每个连接:处理或丢给线程池 */ }

TCP 客户端:socket → inet_pton 转地址(别用 inet_addr,它处理不了 255.255.255.255)→ connect → read/write。

问题答案
htons/htonl 为什么需要网络字节序是大端,主机可能是小端;htonl 用于 32 位地址,htons 用于 16 位端口
SO_REUSEADDR 解决什么重启时 TIME_WAIT 导致 bind: Address already in use
listen 的 backlog已完成三次握手的连接队列上限(半连接队列由 tcp_max_syn_backlog 控制)
INADDR_ANY vs 127.0.0.1前者所有网卡(外部可访问),后者只有本机能连(第四章「本机通外部不通」的元凶)
accept 返回什么新的 fd,代表这个连接;原 lfd 继续监听
怎么设非阻塞fcntl(fd, F_SETFL, O_NONBLOCK)

Unix Domain Socket(本机 IPC 首选,加分项):AF_UNIX 替代 AF_INET,路径替代 IP 端口,不经过协议栈,性能比 TCP 环回高很多,还能传 fd(SCM_RIGHTS)。Redis、MySQL、Docker 的本机通信都用它。

8. 信号安全(高频) ​

c
struct sigaction sa = {0};
sa.sa_handler = handler;
sa.sa_flags = SA_RESTART;      // 自动重启被中断的系统调用
sigaction(SIGINT, &sa, NULL);  // 优于 signal()

铁律:信号处理函数里只能调用「异步信号安全」的函数(write、_exit 等)。不能调 printf、malloc、free —— 它们可能持有锁,而信号可能正好打断持锁代码,导致死锁。

标准写法(self-pipe trick):handler 里只往 pipe 写一个字节,主循环(或 epoll)里做实际处理。

常见信号:SIGINT(Ctrl+C) · SIGTERM · SIGKILL(不可捕获) · SIGHUP(终端关闭/常用来重载配置) · SIGCHLD(子进程状态变化) · SIGPIPE · SIGSEGV。

SIGPIPE 是网络编程的隐形杀手:客户端断开后服务端还 write,默认行为是终止进程。所以服务端要 signal(SIGPIPE, SIG_IGN)(之后 write 返回 -1 + errno == EPIPE),或用 MSG_NOSIGNAL。


十、Shell 与系统管理(速查) ​

1. 变量与引号 ​

bash
name="world"                 # 赋值 = 两边不能有空格!
echo "hello $name"           # 双引号:变量展开
echo 'hello $name'           # 单引号:原样输出
path=$(pwd)                  # 命令替换,推荐 $()
写法含义
$?上一条命令的退出码(0=成功)—— 判断成败全靠它
$# $1 $@参数个数 / 第 1 个 / 参数列表
${var:-default}var 为空时用默认值

铁律:变量引用永远加双引号 "$var"。不加时变量为空会「少一个参数」、文件名带空格会被拆开 —— shell 脚本 90% 的 bug 来源。

生产脚本第一行:set -euo pipefail-e 命令失败立即退出 · -u 用未定义变量报错(防止 rm -rf "$DIR/" 里 DIR 为空删库)· -o pipefail 管道任一环节失败即失败(默认只看最后一个)。

2. 流程控制模板 ​

bash
if [ "$a" -eq 1 ]; then ...; fi      # 数字:-eq -ne -gt -ge -lt -le
if [[ "$a" == "x" && -f "$f" ]]; then ...; fi   # 现代写法(不用纠结空格)
# 字符串:= !=  -z(空) -n(非空);文件:-f -d -e -r -w -x

for i in $(seq 1 10); do echo "$i"; done
while read -r line; do echo "$line"; done < file.txt   # 逐行读文件标准写法

case "$1" in
  start) echo start ;;
  *)     echo "usage: $0 {start|stop}"; exit 1 ;;
esac

greet() { local name="$1"; echo "hi $name"; }   # local 声明局部变量

3. 启动文件加载顺序 ​

Shell 类型加载
登录 shell(ssh、su -)/etc/profile → ~/.bash_profile → ~/.bashrc
非登录交互(新开终端)~/.bashrc
非交互(脚本)只读 $BASH_ENV(默认不读)

实践中环境变量和 alias 统一放 ~/.bashrc(Ubuntu 的 ~/.profile 会 source 它),最不容易踩坑。改完 source ~/.bashrc。

注意:LD_LIBRARY_PATH 写在 ~/.bashrc 里只对交互 shell 生效,systemd 启动的服务读不到 —— 这是「本地跑得好好的,做成服务就找不到 .so」的经典原因。

4. crontab ​

bash
crontab -e / -l
# m h dom mon dow command
# 0 2 * * *     每天 2 点
# */5 * * * *   每 5 分钟
# 0 9 * * 1-5   工作日 9 点

三大坑(「定时任务没执行」怎么查):

  1. PATH 极简(只有 /usr/bin:/bin)→ 脚本里用绝对路径
  2. 看不到输出(cron 的 stdout 发邮件,多数机器没配)→ 重定向 >> /var/log/task.log 2>&1
  3. 环境变量缺失(HOME、LD_LIBRARY_PATH 都没有)→ 脚本里自己 source 或用 bash -lc 包一层

排查:grep CRON /var/log/syslog 或 journalctl -u cron。

5. systemd 与自己写 service(加分项) ​

bash
systemctl start/stop/restart/reload/status nginx
systemctl enable --now nginx                  # 开机自启并立即启动
systemctl daemon-reload                       # 改了 unit 文件后必须执行
journalctl -u nginx -f                        # 实时看服务日志
journalctl -u nginx --since "10 min ago"
journalctl -p err -n 50                       # 最近 50  条错误

/etc/systemd/system/myapp.service:

ini
[Unit]
Description=My C++ Service
After=network.target

[Service]
Type=simple
User=appuser
WorkingDirectory=/opt/myapp
ExecStart=/opt/myapp/app --config /etc/myapp.conf
Environment="LD_LIBRARY_PATH=/opt/myapp/lib"   # ← 服务读不到 .bashrc,环境变量写这
Restart=on-failure                             # 崩溃自动重启
RestartSec=3
LimitNOFILE=65535                              # 提高 fd 上限(网络服务必设)

[Install]
WantedBy=multi-user.target

参考价值:这段能答出来说明你真的部署过服务。LimitNOFILE(fd 上限)、Restart(自动拉起)、Environment(环境变量)是「加分三件套」。

6. 日志与 logrotate ​

层次位置 / 命令
应用日志/var/log/myapp/*.log,tail -F 看
systemd 服务日志journalctl -u 服务名
系统日志/var/log/syslog(Ubuntu) / /var/log/messages(RHEL)
认证日志/var/log/auth.log(登录、sudo)
内核日志dmesg -T(含 OOM Killer、硬件报错)
# /etc/logrotate.d/myapp
/var/log/myapp/*.log {
    daily
    rotate 7
    compress
    missingok
    notifempty
    copytruncate          # 或 postrotate 里 kill -USR1 让程序重开日志
}

copytruncate vs postrotate:前者「拷贝一份再清空」,简单但可能丢几行;后者发信号让程序自己重开文件,更严谨。这就是第五章「文件删了空间不释放」的姊妹考点。

7. 远程与包管理(速查) ​

bash
ssh user@host / ssh-keygen -t ed25519 / ssh-copy-id user@host   # 免密
scp -r dir/ user@host:/path/
rsync -avz --progress src/ user@host:/dst/    # 增量同步,比 scp 快,可续传
apt update / apt install / dpkg -l / dpkg -L 包名               # Debian/Ubuntu

rsync 只传差异(基于大小和 mtime),部署大量文件时比 scp 快一个数量级。apt 是上层(管依赖解析+下载),dpkg 管本地 .deb 包 —— 类比 yum 和 rpm。