exchanger本身不抛invocationtargetexception，该异常必来自交换对象内部的反射调用；应通过result包装或显式解包ite.gettargetexception()来优雅捕获原始异常。
在 Java 中，Exchanger 本身**不会抛出 InvocationTargetException**，它只可能抛出 InterruptedException（线程被中断时）。你遇到的 InvocationTargetException 一定来自你通过 Exchanger.exchange() 交换出去（或接收进来）的某个对象——尤其是该对象内部封装了反射调用（如 Method.invoke()）、Lambda 执行、或第三方框架（如 Spring AOP、JUnit、Mockito）触发的方法调用。
所谓“优雅提取并捕获”，本质是：**在使用 Exchanger 传递可执行逻辑时，统一包装异常，确保调用方能安全识别和处理原始异常（包括 InvocationTargetException 的 getTargetException()）**。
明确异常来源：别让 Exchanger 背锅
Exchanger.exchange() 是同步阻塞操作，它的契约很干净：
- 成功交换 → 返回对方传入的对象（类型由泛型决定）
- 当前线程被中断 → 抛
InterruptedException - 绝不会主动抛
InvocationTargetException
所以，如果你看到 InvocationTargetException，说明你 exchange 的对象（比如一个 Runnable、Supplier<t></t> 或自定义任务类）在执行过程中发生了反射调用失败。异常是在你自己的消费逻辑里“爆发”的，不是 Exchanger 抛的。
推荐做法：用 Result 包装 + 显式解包
不要直接交换原始 Runnable 或 Callable，而是定义一个可携带结果/异常的容器（如 Result<t></t>），让双方约定：交换的是这个容器，执行逻辑放在容器内部，异常被捕获并封装。
示例：
public class Result<t> {
private final T value;
private final Throwable error;
private Result(T value, Throwable error) {
this.value = value;
this.error = error;
}
public static <t> Result<t> success(T value) { return new Result(value, null); }
public static <t> Result<t> failure(Throwable error) { return new Result(null, error); }
public boolean isSuccess() { return error == null; }
public T get() { if (error != null) throw new RuntimeException(error); return value; }
public Throwable getError() { return error; }
// 关键：提供对 InvocationTargetException 底层异常的便捷访问
public Throwable unwrap() {
if (error instanceof InvocationTargetException ite) {
return ite.getTargetException();
}
return error;
}
}</t></t></t></t></t>
使用方式：
- 线程 A 构造
Result>并exchange()出去（或传入待执行逻辑） - 线程 B 收到后，调用其
execute()方法（内部做 try-catch），将结果或异常写回另一个Result再交换回去 - A 拿到响应后，用
result.unwrap()直接拿到原始业务异常（比如NullPointerException、SQLException），无需手动判断instanceof
如果必须交换 Callable/Runnable：加一层 try-catch 包装
若受限于 API 无法改用 Result，至少在执行端强制捕获所有异常：
Exchanger<callable>> ex = new Exchanger();
// 线程 A
Callable<string> task = () -> {
Method m = SomeClass.class.getDeclaredMethod("doWork");
return (String) m.invoke(null); // 可能抛 ITE
};
// 线程 B（收到 task 后）
try {
String result = task.call();
} catch (InvocationTargetException e) {
Throwable cause = e.getTargetException();
// ✅ 这里就能优雅拿到原始异常，比如 IllegalArgumentException
log.error("Task failed with cause:", cause);
handle(cause);
} catch (Exception e) {
log.error("Other error:", e);
}</string></callable>
注意：不要只 catch Exception 就完事——InvocationTargetException 是 Exception 子类，但它的语义特殊（表示反射目标方法失败），必须显式解包才能还原真实问题。
避免陷阱：不要在 exchange 前就触发执行
常见错误写法：
// ❌ 错误：在 exchange 之前就调用了 call()，异常根本不会经过 Exchanger String result = task.call(); // 此处抛 ITE，和 Exchanger 无关 ex.exchange(result);
正确姿势是：把“待执行”作为数据传递，执行动作留在对方线程中发生——这才是 Exchanger 的协作本意。
不复杂但容易忽略：异常不在管道里流动，而是在你亲手触发执行的那一刻爆发。抓住这个关键点，再配合 Result 封装或显式解包，就能真正优雅地处理 InvocationTargetException。
Java免费学习笔记：立即使用
解锁 Java 大师之旅：从入门到精通的终极指南
