
Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。
定位:大型加密货币交易所 Senior Backend Developer - Risk 面试现场实操题应对 原则:所有命令可直接复制粘贴到终端执行,拒绝空泛理论。
目录
- Log Analysis(日志分析)
- Performance Troubleshooting(性能排查)
- Network Diagnostics(网络诊断)
- Regex Quick-Reference(正则速查)
- 面试现场建议
- 常见追问应对
1. Log Analysis(日志分析)
核心场景:Risk 系统产生海量日志(网关 access log、rule engine 执行日志、Kafka 消费日志、JVM GC log、OpenTelemetry trace log)。面试中要求你现场写出能定位问题的命令。
1.1 Find top 10 IPs with most 5xx errors in the last hour
场景:Risk API 网关出现大量 5xx,需快速定位攻击源或故障源 IP。
# Nginx / access.log 标准格式: $remote_addr - - [$time_local] "$request" $status $body_bytes_sent "$http_user_agent"
# 假设日志文件: /var/log/nginx/risk-api-access.log
# 方法 1: awk 精确提取(推荐,性能最好)
awk -v d1="$(date -d '1 hour ago' +'%d/%b/%Y:%H:%M')" '
BEGIN { split(d1, a, "/"); t1 = mktime(a[3] " " a[2] " " a[1] " " 0 " " 0 " " 0) }
{
# 提取时间戳: [14/May/2026:08:32:11
match($0, /\[([0-9]{2})\/([A-Za-z]{3})\/([0-9]{4}):([0-9]{2}):([0-9]{2}):([0-9]{2})/, ts)
logtime = mktime(ts[3] " " ts[2] " " ts[1] " " ts[4] " " ts[5] " " ts[6])
if (logtime >= t1 && $9 ~ /^5/) {
ip[$1]++
}
}
END { for (i in ip) print ip[i], i | "sort -rn | head -n 10" }
' /var/log/nginx/risk-api-access.log
# 方法 2: 如果日志文件名按小时轮转,直接 grep 过滤状态码再统计
grep -E "$(date -d '1 hour ago' +'%d/%b/%Y:%H')" /var/log/nginx/risk-api-access.log \
| awk '$9 ~ /^5/ {print $1}' | sort | uniq -c | sort -rn | head -n 10
# 方法 3: 使用 goaccess 快速分析(如果已安装)
goaccess /var/log/nginx/risk-api-access.log --log-format=COMBINED -o html > report.htmlRisk 场景延伸:如果 5xx 集中在 /api/v1/risk/withdrawal/validate 接口,进一步过滤:
awk '$9 ~ /^5/ && $7 ~ /withdrawal\/validate/ {print $1}' /var/log/nginx/risk-api-access.log \
| sort | uniq -c | sort -rn | head -n 101.2 Extract all withdrawal request IDs that took > 500ms
场景:风控系统处理提现请求耗时过高,需提取所有慢请求 ID 进行后续追踪。
假设日志格式:
2026-05-14T08:30:15.123Z INFO withdraw.validate reqId=WD-20260514-abc123 userId=98765 amount=1.5BTC latencyMs=680 ruleHits=3
# 方法 1: grep + awk 提取 reqId 和 latency
grep "withdraw.validate" /var/log/risk/engine.log \
| awk -F'latencyMs=' '$2 > 500 {
split($0, a, /reqId=/); split(a[2], b, /[ \t]/); print b[1], "latency=" $2 "ms"
}'
# 方法 2: 更健壮的 awk,处理字段顺序不确定的情况
awk '/withdraw\.validate/ {
reqId=""; latency=""
for(i=1;i<=NF;i++) {
if ($i ~ /^reqId=/) reqId=substr($i, 7)
if ($i ~ /^latencyMs=/) latency=substr($i, 11)
}
if (latency+0 > 500) print reqId, latency
}' /var/log/risk/engine.log > /tmp/slow_withdrawals.txt
# 方法 3: 使用 jq 解析 JSON 结构化日志(如果是 JSON 格式)
# 假设日志: {"level":"INFO","msg":"withdraw.validate","reqId":"WD-abc123","latencyMs":680}
jq -r 'select(.latencyMs > 500 and .msg == "withdraw.validate") | .reqId' /var/log/risk/engine.jsonl \
> /tmp/slow_withdrawals.txt1.3 Count Kafka consumer lag per partition
场景:Risk 系统的 Kafka consumer(如交易事件消费、规则引擎触发)出现 lag,需要按 partition 统计。
# 使用 kafka-consumer-groups.sh(Kafka 自带脚本)
KAFKA_HOME=/opt/kafka
$KAFKA_HOME/bin/kafka-consumer-groups.sh \
--bootstrap-server localhost:9092 \
--group risk-rule-engine-group \
--describe
# 输出示例:
# TOPIC PARTITION CURRENT-OFFSET LOG-END-OFFSET LAG CONSUMER-ID
# trade-events 0 1234567 1234600 33 consumer-1
# trade-events 1 2345678 2345705 27 consumer-2
# 提取 LAG > 1000 的 partition(只打印高 lag 分区)
$KAFKA_HOME/bin/kafka-consumer-groups.sh \
--bootstrap-server localhost:9092 \
--group risk-rule-engine-group \
--describe \
| awk 'NR>1 && $5 > 1000 {print "Partition=" $2 " LAG=" $5}'
# 批量检查所有 risk 相关的 consumer group
for group in risk-rule-engine-group risk-withdrawal-group risk-aml-group; do
echo "=== Group: $group ==="
$KAFKA_HOME/bin/kafka-consumer-groups.sh \
--bootstrap-server localhost:9092 \
--group $group \
--describe 2>/dev/null | awk 'NR>1 {sum+=$5} END {print "Total LAG: " sum}'
done
# 使用 kcat (kafkacat) 快速查看 topic partition 的 latest offset
kcat -b localhost:9092 -t trade-events -p 0 -o -1 -f 'Partition %p, Latest Offset %o\n' -e1.4 Parse JVM GC log for long pauses (> 100ms)
场景:Risk 系统的规则引擎或服务运行在 JVM 上,GC 停顿可能导致交易延迟。需从 GC log 中提取 > 100ms 的 pause。
假设使用 G1GC,日志格式:
[2026-05-14T08:30:15.123+0000][gc,start ] GC(1234) Pause Young (Normal) (G1 Evacuation Pause)
[2026-05-14T08:30:15.223+0000][gc ] GC(1234) Pause Young (Normal) (G1 Evacuation Pause) 120M->45M(512M) 100.025ms
# 方法 1: grep 提取含 "Pause" 且时间 > 100ms 的行
grep -E 'Pause.*[0-9]+\.[0-9]+ms' /var/log/risk/gc.log \
| awk '{
match($0, /([0-9]+\.[0-9]+)ms/, m)
if (m[1]+0 > 100) print $0
}'
# 方法 2: 更精确,处理 G1GC unified logging format
awk '/\[gc.*\].*Pause/ {
match($0, /([0-9]+\.[0-9]+)ms/, m)
if (m[1]+0 > 100) {
# 提取 GC ID
match($0, /GC\(([0-9]+)\)/, gc)
print "GC#" gc[1] " " m[1] "ms: " $0
}
}' /var/log/risk/gc.log
# 方法 3: 统计每小时内 > 100ms GC pause 的次数(趋势分析)
grep -oE '[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}.*Pause.*[0-9]+\.[0-9]+ms' /var/log/risk/gc.log \
| awk '{
hour=substr($1, 1, 13)
match($0, /([0-9]+\.[0-9]+)ms/, m)
if (m[1]+0 > 100) count[hour]++
}
END { for (h in count) print h ": " count[h] " long pauses" }' | sort
# 方法 4: 如果是 CMS GC(旧格式)
grep -E "CMS|Full GC|concurrent-mark-sweep" /var/log/risk/gc.log \
| grep -v "[0-9]\.[0-9]{3} secs" # 过滤掉 < 1s 的(粗略)1.5 Filter OpenTelemetry trace logs for a specific trace ID
场景:生产环境一个提现请求超时,需要追踪该请求在 Risk 系统各服务中的完整链路。
假设 trace ID: abcd1234efgh5678ijkl9012mnop3456
TRACE_ID="abcd1234efgh5678ijkl9012mnop3456"
# 方法 1: 在单个日志文件中过滤
grep "$TRACE_ID" /var/log/risk/otel-traces.log
# 方法 2: 跨多个服务日志目录搜索(Risk 系统通常多服务)
find /var/log/risk/ -name "*.log" -type f \
-exec grep -H "$TRACE_ID" {} + \
| awk -F: '{print $1 " [" $2 "]: " $0}' > /tmp/trace_$TRACE_ID.txt
# 方法 3: 使用 ripgrep(更快,支持多线程)
rg "$TRACE_ID" /var/log/risk/ --type log -n > /tmp/trace_$TRACE_ID.txt
# 方法 4: 如果日志是 JSON 格式,提取 span 并按时间排序
rg "$TRACE_ID" /var/log/risk/ --type log \
| jq -s 'sort_by(.timestamp) | .[] | "\(.timestamp) [\(.serviceName)] \(.spanName) duration=\(.durationMs)ms"'
# 方法 5: 提取该 trace 下所有 ERROR level 的 span
rg "$TRACE_ID" /var/log/risk/ --type log \
| jq 'select(.level == "ERROR") | {timestamp, serviceName, spanName, message}'1.6 Aggregate rule-engine hit rates per rule ID
场景:Risk 规则引擎有数百条规则,需要统计每条规则的触发次数和命中率,用于规则优化。
假设日志格式:
2026-05-14T08:30:15Z INFO rule.hit ruleId=RISK_WITHDRAW_001 ruleName=LargeWithdrawalCheck userId=12345 result=HIT latencyMs=12
2026-05-14T08:30:16Z INFO rule.hit ruleId=RISK_WITHDRAW_001 ruleName=LargeWithdrawalCheck userId=12346 result=MISS latencyMs=8
# 统计每条规则的触发总次数、HIT 次数、命中率
awk '/rule\.hit/ {
ruleId=""; result=""; latency=""
for(i=1;i<=NF;i++) {
if ($i ~ /^ruleId=/) ruleId=substr($i, 8)
if ($i ~ /^result=/) result=substr($i, 8)
if ($i ~ /^latencyMs=/) latency=substr($i, 11)
}
if (ruleId != "") {
total[ruleId]++
if (result == "HIT") hit[ruleId]++
lat_sum[ruleId] += latency
}
}
END {
printf "%-25s %10s %10s %8s %12s\n", "RULE_ID", "TOTAL", "HIT", "HIT_RATE", "AVG_LATENCY"
for (r in total) {
rate = (hit[r]/total[r])*100
avg_lat = lat_sum[r]/total[r]
printf "%-25s %10d %10d %7.2f%% %11.2fms\n", r, total[r], hit[r]+0, rate, avg_lat
}
}' /var/log/risk/rule-engine.log | sort -k4 -rn
# 只关注命中率 > 50% 且触发次数 > 1000 的高频规则(这些规则优化收益最大)
# 在上面的 awk 脚本 END 块中加入:
# if (total[r] > 1000 && (hit[r]/total[r]) > 0.5) print r1.7 Real-time tail-following with multi-pattern grep
场景:生产故障排查时,需要实时监控多个服务的日志,同时过滤 ERROR、withdrawal、rule.hit 等关键模式。
# 方法 1: tail -f 多个文件 + grep -E 多模式
tail -f /var/log/risk/api.log /var/log/risk/rule-engine.log /var/log/risk/kafka-consumer.log \
| grep -E "ERROR|WARN|withdrawal|rule\.hit|latencyMs=[0-9]{4,}|GC\(.*Pause"
# 方法 2: 使用 multitail 分屏监控(如果已安装)
multitail -l "tail -f /var/log/risk/api.log" \
-l "tail -f /var/log/risk/rule-engine.log" \
-l "tail -f /var/log/risk/kafka-consumer.log"
# 方法 3: 使用 less +F 查看大文件并支持搜索
less +F /var/log/risk/api.log
# 按 Ctrl+C 停止跟随,输入 /ERROR 搜索,按 F 继续跟随
# 方法 4: 高亮不同级别的日志(使用 awk 着色)
tail -f /var/log/risk/api.log | awk '
/ERROR/ {print "\033[1;31m" $0 "\033[0m"; next}
/WARN/ {print "\033[1;33m" $0 "\033[0m"; next}
/withdrawal.*latencyMs=[0-9]{3,}/ {print "\033[1;35m" $0 "\033[0m"; next}
{print}'
# 方法 5: 实时统计 ERROR 出现频率(每 10 秒刷新)
while true; do
tail -n 10000 /var/log/risk/api.log | grep -c "ERROR"
sleep 10
done2. Performance Troubleshooting(性能排查)
核心思路:先全局(CPU / 内存 / IO / 网络),再局部(进程 / 线程 / 系统调用 / JVM)。
2.1 CPU-bound processes: top, htop, ps
# ===== top =====
# 按 CPU 排序,显示线程模式,刷新间隔 1 秒
top -H -p $(pgrep -d',' -f "risk-engine") -d 1
# top 交互命令(面试常问):
# M -> 按内存排序
# P -> 按 CPU 排序
# T -> 按运行时间排序
# 1 -> 显示每个 CPU 核心
# c -> 显示完整命令行
# H -> 显示线程
# k -> 发送 signal(慎用)
# ===== htop(更友好的交互界面)=====
htop -p $(pgrep -d',' -f "risk-engine")
# F2 设置颜色,F3 搜索,F4 过滤,F5 树形视图,F6 排序
# ===== ps =====
# 按 CPU 使用率排序,显示完整命令行和线程信息
ps -eo pid,ppid,tid,pcpu,pmem,comm,cmd --sort=-pcpu | head -n 20
# 查找 Risk 系统所有 Java 进程及其启动参数
ps -ef | grep java | grep -v grep | awk '{print $2, $NF}'
# 查找占用 CPU 最高的线程(将 tid 转为 16 进制,用于 jstack 分析)
PID=$(pgrep -f "risk-engine")
ps -eLo pid,tid,pcpu,comm | awk -v p="$PID" '$1==p {printf "TID=%s CPU=%s%% HEX=0x%x\n", $2, $3, $2}' | sort -k2 -rn | head -n 52.2 Disk I/O bottlenecks: iostat, iotop, df
# ===== iostat =====
# 每秒刷新,显示扩展统计,重点关注 %util(接近 100% 说明磁盘饱和)
iostat -x -m 1
# 关键指标解读:
# r/s, w/s -> 每秒读写次数
# rkB/s, wkB/s -> 每秒读写吞吐量
# await -> 平均 I/O 等待时间(ms,> 20ms 需警惕)
# %util -> 设备利用率(> 80% 瓶颈)
# 只监控特定磁盘(如 Kafka 数据盘 /data)
iostat -x -m -d /dev/nvme1n1 1
# ===== iotop =====
# 实时显示进程的 IO 使用情况(需要 root)
sudo iotop -o -b -d 5 # -o 只显示有 IO 的进程, -b 批处理模式, -d 间隔 5 秒
# 找出 Risk 系统中哪个进程在狂写磁盘
sudo iotop -b -n 3 | grep -E "(java|risk|kafka)" | head -n 20
# ===== df =====
# 磁盘空间(Kafka 日志、日志文件过大是常见故障)
df -h
# 查看目录占用大小(定位日志膨胀)
du -sh /var/log/risk/* | sort -rh | head -n 10
# 查找大于 1GB 的日志文件(按修改时间排序)
find /var/log/risk/ -type f -size +1G -exec ls -lh {} + | awk '{print $5, $6, $7, $8, $9}' | sort -k3M -k4
# 快速清空大日志文件(不删除文件,避免进程丢失 fd)
> /var/log/risk/api.log
# 或: truncate -s 0 /var/log/risk/api.log2.3 Memory pressure: vmstat, free, sar
# ===== vmstat =====
# 每秒刷新,重点关注 si/so(swap in/out)和 us/sy/id/wa
vmstat 1 10
# 关键指标:
# r -> 运行队列长度(持续 > CPU 核心数说明 CPU 瓶颈)
# b -> 阻塞队列(等待 IO)
# si/so -> swap 活动(任何非 0 都说明内存不足,严重问题)
# us/sy/id/wa -> 用户态/内核态/空闲/等待 IO 的 CPU 时间占比
# free/buff/cache -> 内存状态
# 详细内存统计(单位 MB)
vmstat -s -S M | head -n 20
# ===== free =====
# 人类可读格式,注意 buff/cache 和 available 的区别
free -h
free -m -s 3 # 每 3 秒刷新
# 解读: available = free + cache/buffer 中可快速释放的部分
# 关注 available,而不是 free
# ===== sar =====
# 历史性能数据(如果 sysstat 已安装)
sar -r 1 10 # 内存使用率
sar -B 1 10 # 分页统计(page in/out)
sar -W 1 10 # swap 统计
sar -u 1 10 # CPU
# 查看历史数据(如查看昨天 14:00-15:00 的 CPU)
sar -u -f /var/log/sysstat/sa15 # sa15 表示 15 号的数据2.4 Per-thread CPU profiling: pidstat, perf
# ===== pidstat =====
# 按线程统计 CPU(面试高频命令)
pidstat -u -t -p $(pgrep -f "risk-engine") 1 10
# 按线程统计 IO
pidstat -d -t -p $(pgrep -f "risk-engine") 1 10
# 同时看 CPU + 内存 + IO
pidstat -urd -t -p $(pgrep -f "risk-engine") 1
# ===== perf =====
# 采样 CPU 热点函数(需要安装 perf 和调试符号)
sudo perf top -p $(pgrep -f "risk-engine") -F 99
# 生成火焰图(需配合 FlameGraph 工具)
sudo perf record -F 99 -p $(pgrep -f "risk-engine") -g -- sleep 30
sudo perf script | ./stackcollapse-perf.pl | ./flamegraph.pl > risk-engine-cpu.svg
# 查看某个特定函数的调用次数
sudo perf stat -p $(pgrep -f "risk-engine") -e cycles,instructions,cache-misses sleep 10
# perf 查看热点系统调用
sudo perf top -p $(pgrep -f "risk-engine") --sort=dso,symbol2.5 JVM-specific diagnosis: jstack, jmap, jstat
PID=$(pgrep -f "risk-engine")
# ===== jstat =====
# GC 实时监控(重点)
jstat -gcutil $PID 1000 10 # 每秒输出,共 10 次
# 关键列:
# S0/S1 -> Survivor 区使用率
# E -> Eden 区使用率
# O -> Old 区使用率
# M -> Metaspace 使用率
# YGC/YGCT -> Young GC 次数 / 总时间
# FGC/FGCT -> Full GC 次数 / 总时间
# GCT -> 总 GC 时间
#
# 计算: YGCT/YGC = 每次 Young GC 平均耗时
# 计算: FGCT/FGC = 每次 Full GC 平均耗时
# 堆内存详细统计
jstat -gccapacity $PID 1000 5
# ===== jstack =====
# 导出线程 dump(分析死锁、CPU 高的问题)
jstack -l $PID > /tmp/risk-thread-dump-$(date +%Y%m%d-%H%M%S).txt
# 分析线程 dump:查找死锁
jstack -l $PID | grep -A 20 "Found one Java-level deadlock"
# 查找 WAITING / BLOCKED 状态的线程
jstack -l $PID | grep -E "java.lang.Thread.State: (BLOCKED|WAITING|TIMED_WAITING)" | wc -l
# 结合之前的 pidstat/ps 找到的高 CPU 线程 tid(16进制),在 jstack 中定位
# 假设高 CPU 线程 tid=12345,转 16 进制: printf "%x\n" 12345 -> 0x3039
jstack -l $PID | grep -A 50 "nid=0x3039"
# ===== jmap =====
# 导出堆 dump(分析 OOM,文件很大,注意磁盘空间)
jmap -dump:format=b,file=/tmp/risk-heap.hprof $PID
# 只打印堆概要(不导出文件)
jmap -heap $PID
# 查看堆中对象的统计直方图(找内存大户)
jmap -histo $PID | head -n 30
# 查看类加载器统计(排查 metaspace OOM / 类泄漏)
jmap -clstats $PID
# 分析 heap dump(使用 jhat 或 MAT)
jhat -J-Xmx4g /tmp/risk-heap.hprof # 浏览器访问 7000 端口2.6 Syscall tracing and open file descriptors: strace, lsof
PID=$(pgrep -f "risk-engine")
# ===== strace =====
# 追踪进程的系统调用(定位 hang 住的问题)
# 追踪正在运行的进程(attach,无需重启)
sudo strace -p $PID -f -e trace=network,file,desc -s 256 -o /tmp/strace.log
# 关键参数:
# -p PID -> attach 到运行中的进程
# -f -> 追踪子进程/线程
# -e trace=xx -> 只追踪特定类型的 syscall
# -s 256 -> 打印字符串前 256 字节
# -T -> 显示每个 syscall 耗时
# -tt -> 显示微秒级时间戳
# -o file -> 输出到文件
# 追踪网络相关调用(排查连接问题)
sudo strace -p $PID -f -e trace=network -tt -T
# 追踪文件操作(排查 IO 热点)
sudo strace -p $PID -f -e trace=openat,read,write,close -tt -T \
| awk '{if ($(NF-1) > 0.01) print $(NF-1) "s: " $0}' # 打印 > 10ms 的调用
# 统计最耗时的系统调用
sudo strace -p $PID -f -T -o /tmp/strace.raw
cat /tmp/strace.raw | grep -oE '<[0-9]+\.[0-9]+>' | sed 's/[<>]//g' | sort -rn | head -n 20
# ===== lsof =====
# 查看进程打开的文件描述符(排查 fd 泄漏、连接数过多)
lsof -p $PID | wc -l # 总 fd 数
lsof -p $PID | awk '{print $5}' | sort | uniq -c | sort -rn # 按类型统计
# 查看网络连接状态
lsof -p $PID -i | awk '{print $8}' | sort | uniq -c | sort -rn
# 常见状态: ESTABLISHED, CLOSE_WAIT, TIME_WAIT, SYN_SENT
# 查看 Redis / Kafka / MySQL 的连接 fd
lsof -p $PID -i :6379 # Redis
lsof -p $PID -i :9092 # Kafka
lsof -p $PID -i :3306 # MySQL
# 全局查看端口占用
lsof -i :8080 # Risk API 端口
lsof -i :9088 # RPC 端口
# 查看 CLOSE_WAIT 过多的进程(网络连接泄漏)
lsof -i | grep CLOSE_WAIT | awk '{print $2}' | sort | uniq -c | sort -rn | head -n 53. Network Diagnostics(网络诊断)
核心场景:Risk 系统依赖大量外部服务(Kafka, Redis, MySQL, 下游 RPC, 区块链节点)。网络延迟或连接问题直接导致提现、交易风控延迟。
3.1 Connection states and port usage: netstat, ss
# ===== ss(推荐,比 netstat 更快)=====
# 查看所有监听端口
ss -tlnp
# 查看所有 ESTABLISHED 连接,按状态统计
ss -tan | awk '{print $1}' | sort | uniq -c | sort -rn
# 查看特定端口的连接(如 Risk API 8080)
ss -tan | grep ':8080'
# 查看连接数最多的客户端 IP(排查连接攻击或客户端泄漏)
ss -tan state established | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -rn | head -n 10
# 查看处于 TIME_WAIT 状态的连接(高并发场景常见问题)
ss -tan state time-wait | wc -l
# 只查看与 Redis 的连接状态
ss -tan | grep ':6379' | awk '{print $1}' | sort | uniq -c
# ===== netstat(传统工具,部分系统仍使用)=====
netstat -tlnp # 监听端口
netstat -tan | grep ESTABLISHED | wc -l
netstat -i # 网卡统计(查看丢包、错误)
# 查看连接队列溢出(syn queue / accept queue)
netstat -s | grep -E "listen|overflow|SYN"
# 或: ss -s3.2 Packet capture: tcpdump
# ===== tcpdump 基础用法 =====
# 抓取 eth0 网卡上所有 8080 端口的包(Risk API)
sudo tcpdump -i eth0 port 8080 -w /tmp/risk-api.pcap
# 抓取与 Kafka broker 的通信
sudo tcpdump -i eth0 host kafka-broker-1 -w /tmp/kafka-traffic.pcap
# 抓取 Redis 交互并打印内容(不保存文件,直接看 ASCII)
sudo tcpdump -i lo port 6379 -A -nn | head -n 50
# ===== BPF 过滤表达式(面试重点)=====
# 只抓取 SYN 包(排查连接建立问题)
sudo tcpdump -i eth0 "tcp[tcpflags] & tcp-syn != 0 and tcp[tcpflags] & tcp-ack == 0"
# 只抓取 RST 包(排查连接被重置问题)
sudo tcpdump -i eth0 "tcp[tcpflags] & tcp-rst != 0"
# 抓取大于 100KB 的包(可能有大对象传输)
sudo tcpdump -i eth0 "greater 102400"
# 抓取特定源 IP 和目标端口的流量
sudo tcpdump -i eth0 src 10.0.1.100 and dst port 3306
# 排除 SSH 流量,减少噪音
sudo tcpdump -i eth0 not port 22
# 抓取 HTTP POST 请求(基于 TCP payload 内容过滤)
sudo tcpdump -i eth0 -A -s 0 "tcp port 8080 and (((ip[2:2] - ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0)" | grep -E "POST|Host:|Content-Length:"
# 限制抓包数量,防止磁盘满
sudo tcpdump -i eth0 -c 10000 -W 5 -C 100 -w /tmp/capture.pcap
# -c 10000 -> 抓 10000 个包停止
# -C 100 -> 每个文件 100MB
# -W 5 -> 最多保留 5 个文件(循环覆盖)
# 实时查看 Kafka producer 发送的数据包大小分布
sudo tcpdump -i eth0 port 9092 -nn -tttt | awk '{print $3, $NF}' | grep -E "length [0-9]+"3.3 API endpoint health checks: curl
# ===== curl 详细计时(定位 API 慢问题)=====
# 写一个格式化输出模板,精确到每个阶段耗时
curl -w "\n=== TIME_BREAKDOWN ===\n" \
-w "dns_lookup: %{time_namelookup}s\n" \
-w "tcp_connect: %{time_connect}s\n" \
-w "ssl_handshake: %{time_appconnect}s\n" \
-w "first_byte(TTFB): %{time_starttransfer}s\n" \
-w "total: %{time_total}s\n" \
-w "http_code: %{http_code}\n" \
-w "size_download: %{size_download} bytes\n" \
-o /dev/null -s \
https://api.risk.大型加密货币交易所.com/v1/health
# 解析:
# time_namelookup -> DNS 解析耗时
# time_connect -> TCP 连接耗时(减 DNS = TCP 时间)
# time_appconnect -> TLS 握手耗时
# time_starttransfer -> 首字节时间(TTFB,服务端处理 + 网络往返)
# time_total -> 总耗时
#
# 如果 time_namelookup 高 -> DNS 问题
# 如果 time_connect 高 -> 网络延迟或连接队列满
# 如果 TTFB 高 -> 服务端处理慢(需深入排查)
# 批量测试 Risk API 延迟(100 次请求)
for i in {1..100}; do
curl -o /dev/null -s -w "%{time_total}\n" \
https://api.risk.大型加密货币交易所.com/v1/withdrawal/validate
done | awk '{sum+=$1; count++} END {print "AVG=" sum/count "s, COUNT=" count}'
# 带认证的 API 调用(Risk 系统通常需要 API Key)
curl -H "X-API-KEY: $RISK_API_KEY" \
-H "Content-Type: application/json" \
-d '{"userId":12345,"amount":"1.5","asset":"BTC"}' \
https://api.risk.大型加密货币交易所.com/v1/risk/check
# 测试连接超时和读取超时
curl --connect-timeout 5 --max-time 10 \
https://api.risk.大型加密货币交易所.com/v1/health3.4 Port connectivity tests: nc (netcat)
# ===== nc 基础用法 =====
# 测试 TCP 端口连通性(最常用)
nc -zv kafka-broker-1 9092 # 测试 Kafka 端口
nc -zv redis-cache-1 6379 # 测试 Redis 端口
nc -zv mysql-primary 3306 # 测试 MySQL 端口
# 批量测试多个端口
for host in kafka-1 kafka-2 kafka-3; do
nc -zv $host 9092 && echo "$host:9092 OK" || echo "$host:9092 FAILED"
done
# 测试 Risk RPC 端口(Kitex 通常使用 9088)
nc -zv risk-engine-1 9088
# 监听端口(临时 mock 一个服务)
nc -l 9999 # 在本机 9999 端口监听,可用于测试客户端连接
# 发送原始 HTTP 请求
cat <<EOF | nc api.risk.大型加密货币交易所.com 80
GET /v1/health HTTP/1.1
Host: api.risk.大型加密货币交易所.com
Connection: close
EOF
# UDP 端口测试(如 StatsD 等监控协议)
nc -zvu statsd-agent 81253.5 Routing diagnosis: traceroute, mtr
# ===== traceroute =====
# 追踪到 Kafka broker 的路由路径
traceroute -n -T -p 9092 kafka-broker-1
# -n 不解析主机名(加快速度)
# -T 使用 TCP SYN 而不是 UDP(绕过防火墙)
# -p 指定目标端口
# 追踪到外部风控数据服务商的路由
traceroute -n -I api.thirdparty-risk-provider.com
# -I 使用 ICMP(某些网络只允许 ICMP)
# ===== mtr(推荐,实时综合路由 + 丢包统计)=====
# 实时追踪到数据库主节点的路由质量
mtr -n -T -P 3306 --report --report-cycles 100 mysql-primary
# 关键列解读:
# Loss% -> 该跳的丢包率
# Snt -> 发送包数
# Last/Avg/Best/Wrst -> 延迟统计
# StDev -> 延迟标准差(越大说明越不稳定)
# 持续监控(交互模式)
mtr -n -T -P 9092 kafka-broker-13.6 DNS resolution: dig, nslookup
# ===== dig(推荐,信息更全)=====
# 解析 Risk API 域名
dig api.risk.大型加密货币交易所.com
# 查看完整的 DNS 解析过程(追踪递归查询)
dig +trace api.risk.大型加密货币交易所.com
# 指定 DNS 服务器查询
dig @8.8.8.8 api.risk.大型加密货币交易所.com
# 查看 A 记录和 TTL(排查 DNS 缓存问题)
dig +noall +answer api.risk.大型加密货币交易所.com A
# 反向 DNS 查询(IP 反查域名)
dig -x 10.0.1.100 +short
# 批量测试多个域名的解析时间
for domain in api.risk.大型加密货币交易所.com kafka-1.internal redis-1.internal; do
time=$(dig +stats +time=2 $domain | grep "Query time:" | awk '{print $4}')
echo "$domain: ${time}ms"
done
# ===== nslookup =====
nslookup api.risk.大型加密货币交易所.com
nslookup -type=mx 大型加密货币交易所.com # 查询 MX 记录
# 检查 /etc/resolv.conf 配置的 DNS 是否可达
for server in $(grep nameserver /etc/resolv.conf | awk '{print $2}'); do
dig @$server google.com +short > /dev/null && echo "$server OK" || echo "$server FAILED"
done4. Regex Quick-Reference(正则速查)
面试场景:现场写
grep -E、sed、awk提取日志中的关键字段,或验证数据格式。
4.1 Common patterns
# ===== Email =====
# 基础版:
[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}
# 严格版(排除连续点等):
^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$
# ===== Phone(国际格式,如 +86 13800138000)=====
\+[0-9]{1,3}[ -]?[0-9]{4,14}
# 中国大陆手机号:
1[3-9][0-9]{9}
# 带国家码:
\+86[ -]?1[3-9][0-9]{9}
# ===== IP Address (IPv4) =====
# 基础匹配(不校验范围):
[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}
# 严谨版(使用 grep -P 支持 lookaround,或 Python):
\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b
# ===== Wallet Address =====
# BTC (Base58Check, 26-35 chars):
\b[13][a-km-zA-HJ-NP-Z1-9]{25,34}\b
# BTC Bech32 (SegWit):
\bbc1[a-z0-9]{39,59}\b
# ETH (0x + 40 hex chars):
\b0x[a-fA-F0-9]{40}\b
# ===== UUID =====
\b[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\b
# ===== Timestamp (ISO 8601, 如 2026-05-14T08:30:15.123Z) =====
[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(\.[0-9]{3})?Z?
# ===== Log Level =====
\b(DEBUG|INFO|WARN|WARNING|ERROR|FATAL|TRACE)\b4.2 grep -E / sed / awk regex usage
# ===== grep -E(extended regex)=====
# 匹配 IP 地址
grep -E '\b([0-9]{1,3}\.){3}[0-9]{1,3}\b' /var/log/risk/access.log
# 匹配提现相关的所有日志行
grep -E 'withdraw(al)?\.(validate|process|submit)' /var/log/risk/engine.log
# 匹配 latency > 1000ms 的日志
grep -E 'latencyMs=[0-9]{4,}' /var/log/risk/api.log
# 匹配 error 但不包含 "timeout"(面试常考的排除模式)
grep -i 'error' /var/log/risk/api.log | grep -vi 'timeout'
# ===== sed =====
# 提取 reqId(替换掉整行只留下 reqId)
sed -n 's/.*reqId=\([A-Za-z0-9_-]*\).*/\1/p' /var/log/risk/engine.log
# 删除空行和注释行(处理配置文件)
sed '/^#.*$/d;/^$/d' /etc/risk/config.yml
# 将日期格式从 2026-05-14 转为 14/May/2026
echo "2026-05-14" | sed 's/\([0-9]\{4\}\)-\([0-9]\{2\}\)-\([0-9]\{2\}\)/\3\/\2\/\1/'
# 在每一行开头加上时间戳(处理无时间戳的日志)
sed "s/^/$(date '+%Y-%m-%d %H:%M:%S') /" /var/log/risk/app.log
# ===== awk =====
# awk 默认使用 ERE(在 // 中),支持捕获组(通过 match 函数)
awk 'match($0, /reqId=([A-Z0-9-]+)/, m) {print m[1]}' /var/log/risk/engine.log
# 提取 latencyMs 的值并计算平均数
awk 'match($0, /latencyMs=([0-9]+)/, m) {sum+=m[1]; count++} END {print sum/count}' /var/log/risk/api.log
# 同时提取 ruleId 和 result
awk '{
match($0, /ruleId=([A-Z0-9_]+)/, rid)
match($0, /result=(HIT|MISS)/, res)
if (rid[1] && res[1]) print rid[1], res[1]
}' /var/log/risk/rule-engine.log4.3 Capture groups and back-references
# ===== grep -E 不支持 back-reference(需要使用 grep -P 或 Perl)=====
# 查找重复单词(如 "the the")
grep -P '\b(\w+)\s+\1\b' /var/log/risk/app.log
# ===== sed 中使用 back-reference =====
# 将 "key=value" 改为 "value=key"
echo "latencyMs=500" | sed 's/\(.*\)=\(.*\)/\2=\1/'
# 输出: 500=latencyMs
# 提取引号中的内容
echo 'ruleName="LargeWithdrawalCheck"' | sed 's/.*"\(.*\)".*/\1/'
# ===== awk 中使用 capture groups =====
awk 'match($0, /"([^"]+)"/, m) {print m[1]}' file.txt
# ===== 复杂日志提取示例 =====
# 日志: [2026-05-14 08:30:15] [ERROR] [rule-engine] [reqId=abc123] Rule execution failed: timeout
# 提取: 时间、级别、服务、reqId、消息
awk 'match($0, /\[([0-9-]+ [0-9:]+)\] \[(ERROR|WARN|INFO)\] \[([^\]]+)\] \[reqId=([^\]]+)\] (.*)/, m) {
print "TIME=" m[1] " LEVEL=" m[2] " SERVICE=" m[3] " REQID=" m[4] " MSG=" m[5]
}' /var/log/risk/app.log4.4 Lookahead / lookbehind
# 注意: grep 默认不支持 lookaround,需要使用 grep -P(Perl-compatible)
# ===== 正向前瞻 (Positive Lookahead) =====
# 匹配后面跟着 "withdrawal" 的 "ERROR"
grep -P 'ERROR(?=.*withdrawal)' /var/log/risk/app.log
# ===== 负向前瞻 (Negative Lookahead) =====
# 匹配后面不跟着 "timeout" 的 "ERROR"
grep -P 'ERROR(?!.*timeout)' /var/log/risk/app.log
# ===== 正向后瞻 (Positive Lookbehind) =====
# 匹配前面是 "latencyMs=" 的数字
grep -P '(?<=latencyMs=)[0-9]+' /var/log/risk/api.log
# ===== 负向后瞻 (Negative Lookbehind) =====
# 匹配前面不是 "avgLatencyMs=" 的 "latencyMs=" 后面的数字(排除平均值)
grep -P '(?<!avg)(?<=latencyMs=)[0-9]+' /var/log/risk/api.log
# ===== Python 中更完整的 lookaround 支持 =====
# 如果 grep -P 不可用,用 Python 一行式
python3 -c "
import re, sys
for line in sys.stdin:
if re.search(r'ERROR(?=.*withdrawal)(?!.*retry)', line):
print(line, end='')
" < /var/log/risk/app.log4.5 Common mistakes
# ===== 1. Greedy vs Lazy =====
# 贪婪(默认): .* 匹配尽可能多
# 日志: <tag>content1</tag> <tag>content2</tag>
echo "<tag>content1</tag> <tag>content2</tag>" | grep -oP '<tag>.*</tag>'
# 输出: <tag>content1</tag> <tag>content2</tag> (匹配了全部!)
# 懒惰(非贪婪): .*? 匹配尽可能少
echo "<tag>content1</tag> <tag>content2</tag>" | grep -oP '<tag>.*?</tag>'
# 输出: <tag>content1</tag>
# <tag>content2</tag>
# sed 不支持懒惰匹配, workaround: 使用 [^>]* 代替 .*?
echo "<tag>content1</tag>" | sed 's/<tag>[^<]*<\/tag>/REPLACED/'
# ===== 2. Escaping(转义)=====
# 常见需要转义的字符: . * + ? ^ $ ( ) [ ] { } | \ /
# Bash 中写正则时,要注意 shell 的转义和 regex 的转义是两层!
# 错误示例: shell 会先解释 \1,导致 sed 看不到反斜杠
sed 's/\(.*\)/\1/' # 在某些 shell 中可能出错
# 正确做法: 使用单引号包裹,shell 不会解释
sed 's/\(.*\)/\1/'
# 或者双引号中再转义
sed "s/\\(.*\\)/\\1/"
# ===== 3. 字符类中的特殊处理 =====
# [a-z.] 中的 . 是字面量,不需要转义
# [^0-9] 中的 ^ 表示"非"
# [\]] 匹配右方括号
# [-a-z] 或 [a-z-] 匹配连字符(放开头或结尾)
# ===== 4. 锚点的误用 =====
# ^ 在字符类外表示行首,在字符类内表示"非"
# $ 表示行尾
# \b 表示单词边界(\B 是非单词边界)
# 错误: 匹配包含 "ERROR" 的行不需要锚点
grep '^ERROR$' file # 只匹配整行就是 "ERROR" 的行
grep 'ERROR' file # 匹配包含 "ERROR" 的行
# ===== 5. 量词的误用 =====
# ? = 0 或 1 次
# * = 0 或多次
# + = 1 或多次
# {n,m} = n 到 m 次
# 常见错误: 用 * 匹配 IP 的每一段
[0-9]*\.[0-9]*\.[0-9]*\.[0-9]* # 会匹配空字符串和 "."
# 正确: [0-9]+\.[0-9]+\.[0-9]+\.[0-9]+5. 面试现场建议
5.1 如果忘记了具体命令参数
不要慌,按以下结构化方式回答:
- 描述思路:"这个问题我通常分 X 步来解决。第一步做...,第二步做..."
- 提及核心工具:"对于 CPU 问题,我首先会用
top或htop查看整体负载,然后用pidstat按线程分析..." - 坦诚补充:"具体某个 flag 我可能记不太清,但可以通过
man top或top --help快速确认。如果pidstat不可用,ps配合sort也能做类似的事情。" - 展示替代方案:展示你对工具生态的了解,例如 "除了
ss,netstat也可以看连接状态,只是ss更快;如果都没有,直接读/proc/net/tcp也行。"
5.2 如何展示结构化的排查思路
面试中如果被问到 "线上服务出现 5xx,你怎么排查?",按以下 分层法 回答:
第一层: 快速止血
- 查看告警(PagerDuty / Prometheus Alertmanager)
- 确认影响范围(哪些接口?哪些用户?哪些 region?)
- 检查最近是否有发布(回滚候选)
第二层: 日志定位
- tail -f 实时查看 ERROR 日志
- grep 提取该时间段的 5xx access log
- 按接口聚合,找到异常集中的 endpoint
第三层: 资源排查
- CPU: top/htop -> pidstat/perf -> jstack
- Memory: free/vmstat -> jmap/jstat
- Disk: iostat/iotop -> 检查日志是否打爆磁盘
- Network: ss/netstat -> curl 测试下游服务
第四层: 依赖排查
- Kafka: consumer lag -> broker 健康状态
- Redis: 连接数 -> 慢查询
- MySQL: 慢查询日志 -> 连接池状态
- 下游 RPC: timeout / circuit breaker 状态
第五层: 根因确认与修复
- 找到根因后,先修复再复盘
- 补充监控和告警,防止再发
5.3 处理 "production issue" 场景题
面试官问: "现在生产环境提现接口延迟飙升到 5s,用户投诉,你怎么办?"
回答框架(边说边写命令):
- 确认现象:"我先确认是普遍现象还是局部现象。" 写
curl命令测几个不同 region 的 endpoint。 - 看监控和日志:"同时打开日志和监控大盘。" 写
tail -f和grep过滤/api/v1/withdrawal的日志。 - 分层定位:
- 如果
curl的time_namelookup/time_connect正常,但TTFB很高 -> 服务端问题。 - 写
jstat -gcutil看 GC 是否异常。 - 写
jstack导出线程 dump,看是否有线程 block 在 Kafka / Redis / MySQL。 - 写
ss -tan | grep :3306看数据库连接是否被打满。 - 写
kafka-consumer-groups.sh看是否有 lag 堆积导致消费延迟。
- 如果
- 给出假设:"假设我发现是 Kafka consumer lag 导致,那么..."
- 修复和验证:"临时扩容 consumer、检查是否有 rebalance 异常、确认没有消息积压后,再用 curl 验证延迟恢复正常。"
6. 常见追问应对
Q1: "How would you automate this?"
Answer:
我会将这些命令封装成 Grafana Dashboard + Alertmanager 的监控体系,而不是每次手动敲命令。
- CPU / Memory / IO: 使用 Prometheus Node Exporter 采集,
top和iostat的手工操作转化为 Prometheus Query(如rate(node_cpu_seconds_total[5m]))。- JVM: 使用 JMX Exporter 或 Micrometer 暴露
jvm_gc_pause_seconds_sum、jvm_memory_used_bytes等指标,配置告警规则(如 GC pause > 100ms 触发 PagerDuty)。- Kafka Lag: 使用 Kafka Exporter 暴露
kafka_consumer_group_lag,配置 lag > 10000 的告警。- 日志: 使用 Loki + Promtail 聚合日志,在 Grafana 中直接查询
|~ "ERROR"或| json | latencyMs > 500,无需 SSH 到机器。- 网络: 使用 Blackbox Exporter 定期 curl 关键 endpoint,自动记录 TTFB 和 HTTP code。
但在 故障现场的根因分析 阶段,这些 shell 命令仍然是不可或缺的,因为 exporter 可能也挂了,或者问题太新还没有对应的 metric。
Q2: "What if the log file is 100GB?"
Answer:
直接
grep100GB 文件会导致 OOM 或 IO 打满,必须分而治之:
- 避免全量加载:不要
cat到内存,使用流式处理:zcat(如果是压缩的)或直接用grep/awk流式读取。- 缩小范围:如果知道时间范围,先用
sed -n '/START_TIME/,/END_TIME/p'提取子集,再分析子集。- 并行处理:使用
ripgrep (rg)替代grep(多线程,更快);或者用xargs -P并行处理日志分片。- 外部工具:如果日志在 S3 上,用 Athena 或 S3 Select 直接 SQL 查询;如果在本地,用
awk流式处理(awk是一行一行读,内存占用恒定)。- 预处理建索引:长期方案是用 Loki / Elasticsearch / ClickHouse 对日志建索引,100GB 的原始日志压缩+索引后查询只需毫秒级。
- 采样分析:如果只是想看错误模式,可以
grep "ERROR" | head -n 10000先分析样本,确认模式后再全量统计。
Q3: "How to do this without blocking production?"
Answer:
所有性能分析命令都要考虑 开销 和 安全性:
jmap -dump: 会触发 Full GC,大堆内存(如 32GB)dump 文件本身也占用大量磁盘和 IO。应该在 低峰期 执行,或使用jmap -dump:live只 dump 存活对象减少大小;更安全的做法是开启-XX:+HeapDumpOnOutOfMemoryError和-XX:HeapDumpPath,让 JVM 在 OOM 时自动 dump,而不是手动触发。strace: attach 到运行中的进程会显著降低性能(syscall 拦截开销)。应该在 测试环境 复现问题后再用;生产环境如果必须用,限制追踪范围(-e trace=network而不是全量),且时间要短(timeout 30 strace -p PID)。perf: 采样频率不要太高(-F 99足够),避免-F 1000这种高频采样;使用perf record而不是持续运行的perf top。tcpdump: 抓包会生成大文件,使用-C和-W限制文件大小和数量;避免在流量极高的网卡上长时间抓包。jstack: 相对安全,但频繁执行(每秒一次)也会有一定开销。建议间隔 5-10 秒。- 总体原则: 生产环境优先使用 被动监控(metric、日志),主动诊断只在必要时短时间执行,且要有 回滚/停止方案。
Q4: "What's the difference between tcpdump and Wireshark?"
Answer:
tcpdump是 命令行 抓包工具,适合在 服务器端(无 GUI 的 Linux 环境)使用。它的优势是 轻量、脚本化、资源占用低,可以通过 SSH 直接在生产机器上运行。它使用 BPF (Berkeley Packet Filter) 语法做内核级过滤,效率极高。
Wireshark是 GUI 抓包和分析工具,适合在 本地 使用。它的优势是 可视化解码(自动解析 HTTP、Kafka、MySQL 等协议)、统计图表、追踪流(Follow TCP Stream)、专家分析(自动标记异常包)。Wireshark 的 capture 引擎底层其实也是dumpcap,但分析功能远超 tcpdump。协作流程:生产环境先用
tcpdump -w file.pcap抓包,把.pcap文件下载到本地,再用 Wireshark 做深度分析。这样兼顾了生产环境的可操作性(tcpdump)和本地分析的强大功能(Wireshark)。大型加密货币交易所 Risk 场景:交易风控系统对延迟极度敏感,通常不允许在生产环境安装 Wireshark。
tcpdump是标准工具,抓下来的包用 Wireshark 分析 Kafka 协议、HTTP 请求的延迟细节非常有效。
Q5: "How to find memory leaks in Java?"
Answer:
分 确认泄漏 -> 定位对象 -> 定位代码 三步:
Step 1: 确认泄漏
jstat -gcutil PID 1000持续观察。如果 Old Gen 持续增长、Full GC 后 Old Gen 下降很少、GC 频率越来越高,则确认有泄漏。jstat -gccapacity查看各代容量变化趋势。Step 2: 定位泄漏对象
jmap -histo PID查看对象统计直方图,找 实例数异常多 或 占用内存大 的类(如HashMap$Node、byte[]、String、RiskRuleContext)。- 如果直方图不够清晰,导出 heap dump:
jmap -dump:format=b,file=... PID。- 用 Eclipse MAT (Memory Analyzer Tool) 或 VisualVM 分析
.hprof文件。- 在 MAT 中运行 Leak Suspects Report,它会自动找出 Dominator Tree 中最大的对象和 GC Roots,告诉你是哪个对象持有了大量内存。
- 使用 OQL (Object Query Language) 查询特定类的实例:
SELECT * FROM com.大型加密货币交易所.risk.RuleContext。Step 3: 定位代码
- 在 MAT 中查看 Path to GC Roots,找到是哪个类的哪个字段在持有这些对象。
- 常见泄漏模式:
- 静态集合类无限增长:
static Map<String, Object> cache没有 eviction 策略。- ThreadLocal 未清理:线程池复用线程时,ThreadLocal 里的对象没有
remove()。- 监听器未注销:事件监听器注册后没有反注册,导致被监听对象无法回收。
- 大对象缓存在内存:Kafka consumer 的
poll()拉取消息过大,处理完后没有释放引用。长期方案:集成 Micrometer + Prometheus 暴露 JVM 内存指标,配置 Old Gen 使用率 > 80% 的告警。
Q6: "How to profile a slow SQL query from the OS side?"
Answer:
从 OS 侧分析慢 SQL,本质是看 MySQL 进程在干什么,以及 操作系统资源是否成为瓶颈:
1. 找到 MySQL 进程和具体线程
PID=$(pgrep -x mysqld) # 按 CPU 排序查看 MySQL 线程 ps -eLo pid,tid,pcpu,comm | grep $PID | sort -k3 -rn | head -n 102. 使用
strace追踪 MySQL 的系统调用sudo strace -p $PID -f -e trace=network,file,desc -tt -T -s 256 # 重点看 read/write 的 fd 是否对应数据文件(/var/lib/mysql/...) # 如果 read() 耗时很长,说明磁盘 IO 是瓶颈3. 磁盘 IO 分析
iostat -x -m 1 # 关注 %util 和 await # 如果 MySQL 数据盘 %util 接近 100%,await > 20ms,说明磁盘饱和 # 可能原因:全表扫描、索引缺失、binlog 同步压力大4. 查看 MySQL 连接和锁状态(从 OS 侧切入)
# 查看 MySQL 打开的文件(表文件、socket) lsof -p $PID | grep -E "\.ibd|\.MYD|\.frm" | wc -l # 如果表文件数量异常多,可能是临时表或没有正确关闭的连接 # 查看连接状态 ss -tan | grep :3306 | awk '{print $1}' | sort | uniq -c | sort -rn # 大量 CLOSE_WAIT 或 SYN_RECV 说明连接管理有问题5. 结合 MySQL 内部诊断 OS 侧只能定位到资源瓶颈,具体是哪条 SQL 慢,还需要 MySQL 内部工具:
SHOW PROCESSLIST; -- 看正在执行的查询 SELECT * FROM performance_schema.events_statements_current; -- MySQL 5.6+ SELECT * FROM sys.statements_with_full_table_scans; -- sys schema6. 网络侧 如果 SQL 本身很快,但应用端感觉慢,可能是 网络延迟 或 连接池争抢:
# 抓包看 MySQL 协议交互时间 sudo tcpdump -i eth0 port 3306 -w /tmp/mysql.pcap # 用 Wireshark 分析,看 Query -> Response 之间的时间间隔
Q7: "如果 jstack 打印的线程名都是 pool-1-thread-3 这种,怎么定位具体业务代码?"
Answer:
这是线程池默认命名的问题,面试中展示你对 线程命名规范 和 jstack 分析技巧 的了解:
1. 通过线程栈内容定位
jstack不只是看线程名,更重要的是看 调用栈(Stack Trace)。即使线程名是pool-1-thread-3,它的 stack trace 里会有业务类的包名(如com.大型加密货币交易所.risk.rule.WithdrawalRuleEvaluator.evaluate()),从栈内容可以直接定位业务代码。2. 给线程池命名(最佳实践) 在代码中使用 Guava 的 ThreadFactoryBuilder 或自定义 ThreadFactory:
ThreadFactory namedFactory = new ThreadFactoryBuilder() .setNameFormat("risk-rule-evaluator-%d") .build(); ExecutorService executor = Executors.newFixedThreadPool(10, namedFactory);这样
jstack里看到的是risk-rule-evaluator-0、risk-rule-evaluator-1,一目了然。3. 通过
tid关联 pidstat 先用pidstat -u -t -p PID 1找到高 CPU 的tid,转 16 进制后在jstack中搜索nid=0x...,即使线程名无意义,nid也能精确定位。4. 在 大型加密货币交易所 Risk 场景 Risk 系统的规则引擎通常有多个线程池(rule-evaluation-pool、withdrawal-processing-pool、event-listener-pool),命名良好的线程池在故障排查时可以瞬间区分是 规则计算慢、提现处理慢 还是 事件消费慢。
Q8: "你分析了 GC log,发现每小时有 50 次 Young GC,每次 15ms,这算正常吗?"
Answer:
这取决于具体场景,但我用 ** Risk 系统的 SLA 要求** 来分析:
Young GC 频率和耗时
- 频率:每小时 50 次 = 约每 72 秒一次。对于中等流量服务来说不算异常,但如果流量很低(如凌晨),这个频率可能说明 对象创建速率过高 或 Eden 区太小。
- 耗时:每次 15ms 对于 Young GC 来说属于正常范围(通常 < 50ms 可接受)。
- 但 Risk 系统的关键问题是:如果这 15ms 的 GC 正好发生在 提现验证请求的处理过程中,用户会感受到 15ms 的停顿。对于要求 P99 < 100ms 的风控接口,15ms 占了预算的 15%。
判断标准
- GC 总耗时占比:50 * 15ms = 750ms / 小时 = 0.02%。这个比例非常低,整体影响很小。
- 但要看分布:如果 50 次中有 3 次达到了 100ms(可能是晋升失败或 GC 线程调度延迟),那这 3 次就是问题。
- 还要看业务影响:使用
-XX:+PrintGCApplicationStoppedTime查看实际停顿时间(STW),有时 GC 时间不等于停顿时间。优化方向
- 如果对象生命周期很短(符合风控系统的 request-scoped 对象特征),考虑 增大 Eden 区(
-Xmn),减少 GC 频率。- 如果存在大对象(如批量规则计算的结果集),考虑 G1GC 的
-XX:G1HeapRegionSize或直接使用 ZGC / Shenandoah(低延迟 GC,停顿 < 10ms)。- 开启
-XX:+AlwaysPreTouch避免运行时的内存分页延迟。一句话总结:"每小时 50 次、每次 15ms 的 Young GC 在数值上不算异常,但在 Risk 系统对延迟极度敏感的场景下,我会进一步分析这 15ms 是否与 P99 延迟毛刺相关,并考虑通过调大新生代或切换到 ZGC 来彻底消除停顿担忧。"
文档结束。建议在实际面试前,挑选 3-5 个最可能被问到的命令,在本地虚拟机或容器里实操一遍,确保手速和流畅度。