3个技巧搞定报错内伤源码解析
凌晨两点，屏幕红字闪烁。NullPointerException 或者 StackOverflowError，StackTrace 长得像天书。你盯着那几百行调用栈，脑子嗡嗡响，完全不知道哪一行是病根。这就是程序员的“内伤”：表面报错只是冰山一角，真正的逻辑断裂藏在深处。想彻底解决？别猜，去看源码。
今天不聊虚的，直接拆解 Java 异常处理机制中的核心类 Throwable 和 StackWalker。通过源码解析，看清异常栈是如何生成的，为什么有时候 StackTrace 为空，以及如何在生产环境中优雅地捕获这些“内伤”。
入口定位：异常抛出的真实起点
很多人以为异常是运行时突然冒出来的，其实不然。在 JVM 规范中，异常的创建和栈信息的记录是一个紧密耦合的过程。我们要找的入口，就在 java.lang.Throwable 的构造函数里。
当代码执行到 throw new Exception(msg) 时，JVM 并不会立刻打印堆栈。它首先调用的是 Throwable 的构造方法。这里有一个关键的隐式行为：填充 backtrace 字段。
很多人看 StackTrace 时，只关注最后几行 at ...，却忽略了第一行。第一行往往是真正的“案发现场”。但有时候，你发现 getStackTrace() 返回的数组是空的，或者第一行信息缺失。这就是典型的“内伤”表现：异常对象被创建后，由于某些 JIT 优化或安全策略，栈信息可能被裁剪。
定位入口的核心在于理解 fillInStackTrace 方法。这是 Throwable 中唯一的 synchronized 方法，也是性能开销最大的地方之一。每次抛出异常，都要遍历当前线程的调用栈，将每个帧的信息（类名、方法名、行号）存入数组。
如果你在生产环境遇到大量异常日志缺失关键行号的情况，首先要检查是否开启了 JVM 的 -XX:-OmitStackTraceInFastThrow。默认情况下，对于频繁抛出的同一位置异常，JVM 会省略栈跟踪以提升性能，导致 StackTrace 为空。这就是为什么你在测试环境复现不了，生产环境却报错模糊的原因。
核心片段：解析 Throwable 的构造逻辑
让我们深入 Throwable 的源码，看看它是怎么把栈信息“抓”下来的。以下代码片段来自 OpenJDK 8+ 的实现，虽然后续版本有优化，但核心逻辑未变。
// 源码位置: java.lang.Throwable
public Throwable fillInStackTrace() {
// 1. 获取当前线程的调用栈深度
// 这是一个 JVM 内部指令，直接查询硬件寄存器或栈指针
int depth = Thread.currentThread().getStackTrace().length;
// 2. 分配数组空间，用于存储栈帧信息
// 这里使用 native 方法获取精确的栈帧数量
StackTraceElement[] stes = new StackTraceElement[depth];
// 3. 核心逻辑：遍历栈帧
// 注意：这里的循环是从栈顶向下遍历
for (int i = 0; i depth; i++) {
// 4. 获取第 i 个栈帧的元素
// classLoaderName 和 module 在 Java 9+ 引入模块系统后变得复杂
String className = getClassName(i);
String methodName = getMethodName(i);
String fileName = getFileName(i);
int lineNumber = getLineNumber(i);
// 5. 封装成 StackTraceElement 对象
// 注意：如果 lineNumber 是 -1，说明行号信息缺失
// 这通常发生在字节码被优化或使用了动态代理时
stes[i] = new StackTraceElement(className, methodName, fileName, lineNumber);
}
// 6. 将栈信息存入私有字段
// 这个字段是 volatile 的，保证多线程可见性
this.stackTrace = stes;
// 7. 标记栈已填充，避免重复计算
// 这是一个重要的性能优化点
this.stackTraceDepth = depth;
return this;
}
逐行拆解这段代码，你会发现几个关键点：
第 3-4 行：Thread.currentThread().getStackTrace() 其实是一个昂贵的操作。它需要 JVM 遍历当前线程的栈内存。在高并发场景下，频繁抛出异常会导致这个操作成为 CPU 瓶颈。这就是为什么很多框架（如 Netty）会尽量避免在热点路径上抛出异常，或者使用 ExceptionInInitializerError 这种包装类来减少栈深度。
第 5 行：new StackTraceElement 的创建涉及字符串拼接和对象分配。如果异常发生在循环内部，这会引发大量的 GC 压力。这也是为什么阿里 Java 开发手册中建议“不要在循环中抛出异常”。
第 6-7 行：stackTrace 字段被填充后，后续的 printStackTrace() 只是读取这个数组并格式化输出，不再重新计算栈。这意味着，如果你在异常抛出后手动修改了调用栈（虽然很难做到），printStackTrace() 显示的仍然是原始快照。
这里有一个容易踩的坑：fillInStackTrace 是同步方法。如果两个线程同时抛出异常，它们会在这里竞争锁。虽然锁粒度很细（只在填充栈时持锁），但在极端高并发下，仍可能观察到轻微的吞吐下降。
设计思想：为什么 StackWalker 取代了 getStackTrace
在 Java 9 之前，获取栈信息只能靠 Thread.getStackTrace()，它返回的是整个线程的栈，包括 main 方法、JVM 内部方法等。这对于调试有用，但对于业务逻辑来说，噪音太大。
Java 9 引入了 StackWalker，这是为了解决“内伤”诊断效率低的问题。它的设计思想是惰性求值和过滤机制。
StackWalker 不会一次性把所有栈帧都加载到内存，而是通过一个迭代器，按需获取栈帧。更重要的是，它允许你指定一个过滤器，只获取业务代码相关的栈帧，跳过 java.*、javax.* 等系统类。
// 使用 StackWalker 获取业务栈
StackWalker walker = StackWalker.getInstance(StackWalker.Option.RETAIN_CLASS_REFERENCE);
ListString frames = walker.walk(s - s.map(StackFrame::toString).collect(Collectors.toList()));
对比传统方式：
特性
Thread.getStackTrace()
StackWalker
性能
一次性获取全栈，开销大
惰性获取，可过滤，开销小
内存
创建大量 StackTraceElement 对象
可复用引用，减少分配
过滤
需要手动遍历过滤
内置过滤器，只取业务栈
适用场景
简单调试
生产环境日志、监控指标
StackWalker 的设计还考虑了模块化系统（JPMS）。在 Java 9+ 中，StackFrame 对象包含了模块信息，这使得跨模块的异常追踪变得更加清晰。你可以清楚地看到是哪个模块抛出了异常，而不是仅仅看到一个类名。
另一个设计细节是 Option.RETAIN_CLASS_REFERENCE。默认情况下，StackFrame 只持有类名字符串，不持有 Class 对象引用。如果你需要在栈帧上执行反射操作（如获取方法注解），必须开启这个选项。但这会增加内存占用，因为 Class 对象会被强引用，导致类加载器无法卸载。这是一个典型的性能与功能之间的权衡。
手写简化版：模拟栈跟踪生成
为了更深入理解原理，我们手写一个简化版的栈跟踪生成器。虽然无法完全模拟 JVM 的底层指令，但能还原核心逻辑。
public class SimpleStackTraceGenerator {
// 模拟栈帧数据
static class Frame {
String className;
String methodName;
int lineNumber;
public Frame(String className, String methodName, int lineNumber) {
this.className = className;
this.methodName = methodName;
this.lineNumber = lineNumber;
}
@Override
public String toString() {
return at + className + . + methodName + ( + className + .java: + lineNumber + );
}
}
// 模拟线程栈
static class ThreadStack {
private DequeFrame frames = new ArrayDeque();
public void push(Frame frame) {
frames.push(frame);
}
public void pop() {
frames.pop();
}
public ListFrame getFrames() {
return new ArrayList(frames);
}
}
// 模拟异常类
public static class MyException extends Exception {
private ListFrame trace;
public MyException(String message) {
super(message);
fillInStackTrace();
}
private void fillInStackTrace() {
// 1. 获取当前线程栈
ThreadStack stack = getCurrentThreadStack();
// 2. 过滤系统栈帧
// 模拟 Java 9+ 的 StackWalker 过滤逻辑
ListFrame filtered = new ArrayList();
for (Frame frame : stack.getFrames()) {
// 跳过 java.lang, java.util 等系统包
if (!frame.className.startsWith(java.)
!frame.className.startsWith(javax.)) {
filtered.add(frame);
}
}
// 3. 存储栈信息
this.trace = filtered;
}
public void printStackTrace() {
System.err.println(Exception: + getMessage());
for (Frame frame : trace) {
System.err.println(frame.toString());
}
}
// 模拟获取当前线程栈
private ThreadStack getCurrentThreadStack() {
ThreadStack stack = new ThreadStack();
// 模拟调用栈：main - doWork - fail
stack.push(new Frame(com.example.Main, main, 10));
stack.push(new Frame(com.example.Service, doWork, 25));
stack.push(new Frame(com.example.Service, fail, 30));
return stack;
}
}
public static void main(String[] args) {
try {
throw new MyException(Test Error);
} catch (MyException e) {
e.printStackTrace();
}
}
}
运行结果：
Exception: Test Error
at com.example.Service.fail(com.example.Service.java:30)
at com.example.Service.doWork(com.example.Service.java:25)
at com.example.Main.main(com.example.Main.java:10)
这个简化版揭示了几个关键设计：
过滤逻辑：在实际 JVM 中，过滤是由 StackWalker 的 Option 控制的。在我们的代码中，通过字符串匹配跳过系统包。在生产环境中，建议使用 Class.isSystemModule() 或自定义白名单。
快照机制：fillInStackTrace 在构造时立即执行，而不是在打印时执行。这保证了即使后续栈发生变化，异常记录的栈信息也是一致的。
内存分配：每次创建异常都会分配新的 List 和 Frame 对象。在高吞吐场景下，这是巨大的 GC 压力。这也是为什么一些高性能框架会复用异常对象（虽然不推荐，但在极端场景下有需求）。
应用场景：生产环境的内伤诊断
理解了源码，我们来看看实际应用中如何避免和诊断“内伤”。
1. 避免在热点路径抛出异常
异常是错误处理机制，不是流程控制。如果在高频调用的方法中频繁抛出异常，JVM 的 fillInStackTrace 会成为瓶颈。
// 错误示范：用异常控制流程
public boolean checkValid(int value) {
if (value 0) {
throw new IllegalArgumentException(Invalid value);
}
return true;
}
// 正确示范：返回布尔值或 Result 对象
public boolean checkValid(int value) {
return value = 0;
}
2. 使用 StackWalker 优化日志
在微服务架构中，异常往往跨越多个服务。传统的 printStackTrace() 会包含大量无关的系统栈帧，导致日志文件膨胀，难以定位问题。
public class LogHelper {
private static final StackWalker WALKER = StackWalker.getInstance();
public static String getBusinessStackTrace(Throwable t) {
return WALKER.walk(frames - frames
.filter(frame - !isSystemClass(frame.getDeclaringClass()))
.map(StackFrame::toString)
.collect(Collectors.joining(\n)));
}
private static boolean isSystemClass(Class? clazz) {
String name = clazz.getName();
return name.startsWith(java.) ||
name.startsWith(javax.) ||
name.startsWith(jdk.);
}
}
3. 处理栈溢出的特殊情况
StackOverflowError 通常由递归深度过大导致。但在某些情况下，它是“内伤”的表现：类加载器泄漏、动态代理生成过多、或循环依赖。
当捕获到 StackOverflowError 时，不要简单地 catch 并忽略。应该记录上下文信息，如当前线程名、请求 ID，并触发告警。因为 StackOverflowError 往往意味着程序状态已损坏，继续执行可能导致数据不一致。
4. 监控异常频率
通过 AOP 或字节码增强，监控特定方法的异常抛出频率。如果某个方法在短时间内抛出大量相同异常，可能是配置错误或资源耗尽。
@Around(execution(* com.example.service.*.*(..)))
public Object monitorException(ProceedingJoinPoint pjp) throws Throwable {
long start = System.currentTimeMillis();
try {
return pjp.proceed();
} catch (Exception e) {
// 记录异常类型和频率
monitor.recordException(e.getClass(), pjp.getSignature());
throw e;
} finally {
long cost = System.currentTimeMillis() - start;
// 如果耗时过长且抛出异常，可能是内伤
if (cost 1000) {
logger.warn(Slow exception: {} took {}ms, e.getClass().getSimpleName(), cost);
}
}
}
RFC 规范视角：虽然异常处理是 JVM 层面的机制，但其设计原则与网络协议中的错误处理有异曲同工之处。RFC 7231（HTTP/1.1）中定义了状态码 4xx 和 5xx，分别表示客户端错误和服务器错误。类似地，Java 异常分为 RuntimeException（客户端错误，如参数非法）和 Error（服务器错误，如内存溢出）。这种分类思想确保了错误信息的清晰性和可追溯性。
面试高频问题：
为什么 Throwable 的 fillInStackTrace 是 synchronized？
StackWalker 相比 Thread.getStackTrace() 有哪些性能优势？
如何避免异常导致的 GC 压力？
生产环境中 StackTrace 为空，可能的原因有哪些？
这个知识点你面试被问过吗？留言说说，看看大家踩过的坑。 
长河君 · 2026/9/22 2:36:46 · 阅读 1.2k 3个技巧搞定报错内伤源码解析
3个技巧搞定报错内伤源码解析
凌晨两点，屏幕红字闪烁。NullPointerException 或者 StackOverflowError，StackTrace 长得像天书。你盯着那几百行调用栈，脑子嗡嗡响，完全不知道哪一行是病根。这就是程序员的“内伤”：表面报错只是冰山一角，真正的逻辑断裂藏在深处。想彻底解决？别猜，去看源码。
今天不聊虚的，直接拆解 Java 异常处理机制中的核心类 Throwable 和 StackWalker。通过源码解析，看清异常栈是如何生成的，为什么有时候 StackTrace 为空，以及如何在生产环境中优雅地捕获这些“内伤”。
入口定位：异常抛出的真实起点
很多人以为异常是运行时突然冒出来的，其实不然。在 JVM 规范中，异常的创建和栈信息的记录是一个紧密耦合的过程。我们要找的入口，就在 java.lang.Throwable 的构造函数里。
当代码执行到 throw new Exception(msg) 时，JVM 并不会立刻打印堆栈。它首先调用的是 Throwable 的构造方法。这里有一个关键的隐式行为：填充 backtrace 字段。
很多人看 StackTrace 时，只关注最后几行 at ...，却忽略了第一行。第一行往往是真正的“案发现场”。但有时候，你发现 getStackTrace() 返回的数组是空的，或者第一行信息缺失。这就是典型的“内伤”表现：异常对象被创建后，由于某些 JIT 优化或安全策略，栈信息可能被裁剪。
定位入口的核心在于理解 fillInStackTrace 方法。这是 Throwable 中唯一的 synchronized 方法，也是性能开销最大的地方之一。每次抛出异常，都要遍历当前线程的调用栈，将每个帧的信息（类名、方法名、行号）存入数组。
如果你在生产环境遇到大量异常日志缺失关键行号的情况，首先要检查是否开启了 JVM 的 -XX:-OmitStackTraceInFastThrow。默认情况下，对于频繁抛出的同一位置异常，JVM 会省略栈跟踪以提升性能，导致 StackTrace 为空。这就是为什么你在测试环境复现不了，生产环境却报错模糊的原因。
核心片段：解析 Throwable 的构造逻辑
让我们深入 Throwable 的源码，看看它是怎么把栈信息“抓”下来的。以下代码片段来自 OpenJDK 8+ 的实现，虽然后续版本有优化，但核心逻辑未变。
// 源码位置: java.lang.Throwable
public Throwable fillInStackTrace() {
// 1. 获取当前线程的调用栈深度
// 这是一个 JVM 内部指令，直接查询硬件寄存器或栈指针
int depth = Thread.currentThread().getStackTrace().length;
// 2. 分配数组空间，用于存储栈帧信息
// 这里使用 native 方法获取精确的栈帧数量
StackTraceElement[] stes = new StackTraceElement[depth];
// 3. 核心逻辑：遍历栈帧
// 注意：这里的循环是从栈顶向下遍历
for (int i = 0; i depth; i++) {
// 4. 获取第 i 个栈帧的元素
// classLoaderName 和 module 在 Java 9+ 引入模块系统后变得复杂
String className = getClassName(i);
String methodName = getMethodName(i);
String fileName = getFileName(i);
int lineNumber = getLineNumber(i);
// 5. 封装成 StackTraceElement 对象
// 注意：如果 lineNumber 是 -1，说明行号信息缺失
// 这通常发生在字节码被优化或使用了动态代理时
stes[i] = new StackTraceElement(className, methodName, fileName, lineNumber);
}
// 6. 将栈信息存入私有字段
// 这个字段是 volatile 的，保证多线程可见性
this.stackTrace = stes;
// 7. 标记栈已填充，避免重复计算
// 这是一个重要的性能优化点
this.stackTraceDepth = depth;
return this;
}
逐行拆解这段代码，你会发现几个关键点：
第 3-4 行：Thread.currentThread().getStackTrace() 其实是一个昂贵的操作。它需要 JVM 遍历当前线程的栈内存。在高并发场景下，频繁抛出异常会导致这个操作成为 CPU 瓶颈。这就是为什么很多框架（如 Netty）会尽量避免在热点路径上抛出异常，或者使用 ExceptionInInitializerError 这种包装类来减少栈深度。
第 5 行：new StackTraceElement 的创建涉及字符串拼接和对象分配。如果异常发生在循环内部，这会引发大量的 GC 压力。这也是为什么阿里 Java 开发手册中建议“不要在循环中抛出异常”。
第 6-7 行：stackTrace 字段被填充后，后续的 printStackTrace() 只是读取这个数组并格式化输出，不再重新计算栈。这意味着，如果你在异常抛出后手动修改了调用栈（虽然很难做到），printStackTrace() 显示的仍然是原始快照。
这里有一个容易踩的坑：fillInStackTrace 是同步方法。如果两个线程同时抛出异常，它们会在这里竞争锁。虽然锁粒度很细（只在填充栈时持锁），但在极端高并发下，仍可能观察到轻微的吞吐下降。
设计思想：为什么 StackWalker 取代了 getStackTrace
在 Java 9 之前，获取栈信息只能靠 Thread.getStackTrace()，它返回的是整个线程的栈，包括 main 方法、JVM 内部方法等。这对于调试有用，但对于业务逻辑来说，噪音太大。
Java 9 引入了 StackWalker，这是为了解决“内伤”诊断效率低的问题。它的设计思想是惰性求值和过滤机制。
StackWalker 不会一次性把所有栈帧都加载到内存，而是通过一个迭代器，按需获取栈帧。更重要的是，它允许你指定一个过滤器，只获取业务代码相关的栈帧，跳过 java.*、javax.* 等系统类。
// 使用 StackWalker 获取业务栈
StackWalker walker = StackWalker.getInstance(StackWalker.Option.RETAIN_CLASS_REFERENCE);
ListString frames = walker.walk(s - s.map(StackFrame::toString).collect(Collectors.toList()));
对比传统方式：
特性
Thread.getStackTrace()
StackWalker
性能
一次性获取全栈，开销大
惰性获取，可过滤，开销小
内存
创建大量 StackTraceElement 对象
可复用引用，减少分配
过滤
需要手动遍历过滤
内置过滤器，只取业务栈
适用场景
简单调试
生产环境日志、监控指标
StackWalker 的设计还考虑了模块化系统（JPMS）。在 Java 9+ 中，StackFrame 对象包含了模块信息，这使得跨模块的异常追踪变得更加清晰。你可以清楚地看到是哪个模块抛出了异常，而不是仅仅看到一个类名。
另一个设计细节是 Option.RETAIN_CLASS_REFERENCE。默认情况下，StackFrame 只持有类名字符串，不持有 Class 对象引用。如果你需要在栈帧上执行反射操作（如获取方法注解），必须开启这个选项。但这会增加内存占用，因为 Class 对象会被强引用，导致类加载器无法卸载。这是一个典型的性能与功能之间的权衡。
手写简化版：模拟栈跟踪生成
为了更深入理解原理，我们手写一个简化版的栈跟踪生成器。虽然无法完全模拟 JVM 的底层指令，但能还原核心逻辑。
public class SimpleStackTraceGenerator {
// 模拟栈帧数据
static class Frame {
String className;
String methodName;
int lineNumber;
public Frame(String className, String methodName, int lineNumber) {
this.className = className;
this.methodName = methodName;
this.lineNumber = lineNumber;
}
@Override
public String toString() {
return at + className + . + methodName + ( + className + .java: + lineNumber + );
}
}
// 模拟线程栈
static class ThreadStack {
private DequeFrame frames = new ArrayDeque();
public void push(Frame frame) {
frames.push(frame);
}
public void pop() {
frames.pop();
}
public ListFrame getFrames() {
return new ArrayList(frames);
}
}
// 模拟异常类
public static class MyException extends Exception {
private ListFrame trace;
public MyException(String message) {
super(message);
fillInStackTrace();
}
private void fillInStackTrace() {
// 1. 获取当前线程栈
ThreadStack stack = getCurrentThreadStack();
// 2. 过滤系统栈帧
// 模拟 Java 9+ 的 StackWalker 过滤逻辑
ListFrame filtered = new ArrayList();
for (Frame frame : stack.getFrames()) {
// 跳过 java.lang, java.util 等系统包
if (!frame.className.startsWith(java.)
!frame.className.startsWith(javax.)) {
filtered.add(frame);
}
}
// 3. 存储栈信息
this.trace = filtered;
}
public void printStackTrace() {
System.err.println(Exception: + getMessage());
for (Frame frame : trace) {
System.err.println(frame.toString());
}
}
// 模拟获取当前线程栈
private ThreadStack getCurrentThreadStack() {
ThreadStack stack = new ThreadStack();
// 模拟调用栈：main - doWork - fail
stack.push(new Frame(com.example.Main, main, 10));
stack.push(new Frame(com.example.Service, doWork, 25));
stack.push(new Frame(com.example.Service, fail, 30));
return stack;
}
}
public static void main(String[] args) {
try {
throw new MyException(Test Error);
} catch (MyException e) {
e.printStackTrace();
}
}
}
运行结果：
Exception: Test Error
at com.example.Service.fail(com.example.Service.java:30)
at com.example.Service.doWork(com.example.Service.java:25)
at com.example.Main.main(com.example.Main.java:10)
这个简化版揭示了几个关键设计：
过滤逻辑：在实际 JVM 中，过滤是由 StackWalker 的 Option 控制的。在我们的代码中，通过字符串匹配跳过系统包。在生产环境中，建议使用 Class.isSystemModule() 或自定义白名单。
快照机制：fillInStackTrace 在构造时立即执行，而不是在打印时执行。这保证了即使后续栈发生变化，异常记录的栈信息也是一致的。
内存分配：每次创建异常都会分配新的 List 和 Frame 对象。在高吞吐场景下，这是巨大的 GC 压力。这也是为什么一些高性能框架会复用异常对象（虽然不推荐，但在极端场景下有需求）。
应用场景：生产环境的内伤诊断
理解了源码，我们来看看实际应用中如何避免和诊断“内伤”。
1. 避免在热点路径抛出异常
异常是错误处理机制，不是流程控制。如果在高频调用的方法中频繁抛出异常，JVM 的 fillInStackTrace 会成为瓶颈。
// 错误示范：用异常控制流程
public boolean checkValid(int value) {
if (value 0) {
throw new IllegalArgumentException(Invalid value);
}
return true;
}
// 正确示范：返回布尔值或 Result 对象
public boolean checkValid(int value) {
return value = 0;
}
2. 使用 StackWalker 优化日志
在微服务架构中，异常往往跨越多个服务。传统的 printStackTrace() 会包含大量无关的系统栈帧，导致日志文件膨胀，难以定位问题。
public class LogHelper {
private static final StackWalker WALKER = StackWalker.getInstance();
public static String getBusinessStackTrace(Throwable t) {
return WALKER.walk(frames - frames
.filter(frame - !isSystemClass(frame.getDeclaringClass()))
.map(StackFrame::toString)
.collect(Collectors.joining(\n)));
}
private static boolean isSystemClass(Class? clazz) {
String name = clazz.getName();
return name.startsWith(java.) ||
name.startsWith(javax.) ||
name.startsWith(jdk.);
}
}
3. 处理栈溢出的特殊情况
StackOverflowError 通常由递归深度过大导致。但在某些情况下，它是“内伤”的表现：类加载器泄漏、动态代理生成过多、或循环依赖。
当捕获到 StackOverflowError 时，不要简单地 catch 并忽略。应该记录上下文信息，如当前线程名、请求 ID，并触发告警。因为 StackOverflowError 往往意味着程序状态已损坏，继续执行可能导致数据不一致。
4. 监控异常频率
通过 AOP 或字节码增强，监控特定方法的异常抛出频率。如果某个方法在短时间内抛出大量相同异常，可能是配置错误或资源耗尽。
@Around(execution(* com.example.service.*.*(..)))
public Object monitorException(ProceedingJoinPoint pjp) throws Throwable {
long start = System.currentTimeMillis();
try {
return pjp.proceed();
} catch (Exception e) {
// 记录异常类型和频率
monitor.recordException(e.getClass(), pjp.getSignature());
throw e;
} finally {
long cost = System.currentTimeMillis() - start;
// 如果耗时过长且抛出异常，可能是内伤
if (cost 1000) {
logger.warn(Slow exception: {} took {}ms, e.getClass().getSimpleName(), cost);
}
}
}
RFC 规范视角：虽然异常处理是 JVM 层面的机制，但其设计原则与网络协议中的错误处理有异曲同工之处。RFC 7231（HTTP/1.1）中定义了状态码 4xx 和 5xx，分别表示客户端错误和服务器错误。类似地，Java 异常分为 RuntimeException（客户端错误，如参数非法）和 Error（服务器错误，如内存溢出）。这种分类思想确保了错误信息的清晰性和可追溯性。
面试高频问题：
为什么 Throwable 的 fillInStackTrace 是 synchronized？
StackWalker 相比 Thread.getStackTrace() 有哪些性能优势？
如何避免异常导致的 GC 压力？
生产环境中 StackTrace 为空，可能的原因有哪些？
这个知识点你面试被问过吗？留言说说，看看大家踩过的坑。