Java SwitchPoint失效后为什么不能重新启用

如果你把 SwitchPoint 当成可以反复拨动的开关，就会在 invalidateAll() 之后遇到一个看似奇怪的结果：旧的守卫一直走 fallback，即使业务状态已经“恢复”，target 也不会再次生效。原因很简单：SwitchPoint 的失效是单向的，官方 API 明确规定它不能反转。

官方地址：https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/lang/invoke/SwitchPoint.html

旧 SwitchPoint 不能重新启用。要开始下一轮有效状态，应该创建新的 SwitchPoint，再用新的 guardWithTest(target, fallback) 生成新的守卫句柄；旧 guard 只能继续承担失效后的 fallback 语义。

先把 SwitchPoint 看成一次性状态发布器

一个新建的 SwitchPoint 处于 valid 状态。调用 guardWithTest(target, fallback) 后，会得到一个新的方法句柄：在当前 SwitchPoint 有效时调用 target，失效后调用 fallback。

这里的关键不是“每次调用都重新判断一个可恢复开关”，而是把一组 target/fallback 与这个 SwitchPoint 关联起来。调用 SwitchPoint.invalidateAll(new SwitchPoint[]{ point }) 后，这个点进入 invalid 状态，关联的守卫永久改走 fallback。

invalidateAll 之后为什么不能回到 target

invalidateAll 的名字容易让人以为只是“刷新一次缓存”。但它实际做的是把传入的一个或多个 SwitchPoint 设置为 invalid。官方定义有两个直接后果：

• 失效是全局可见的，其他线程不会继续观察到有效状态。
• 失效是永久的，同一个 SwitchPoint 只能改变一次状态。

因此，下面这段代码里，第一次调用 guarded 走 target，失效后走 fallback；不存在第三次调用又自动回到 target 的阶段。

import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.invoke.SwitchPoint;

public class OneWaySwitchPoint {
    public static void main(String[] args) throws Throwable {
        // 两个句柄必须保持完全相同的方法类型，才能组成一个守卫句柄。
        MethodType type = MethodType.methodType(String.class, String.class);
        MethodHandle target = MethodHandles.lookup()
                .findStatic(OneWaySwitchPoint.class, "current",
                        type);
        MethodHandle fallback = MethodHandles.lookup()
                .findStatic(OneWaySwitchPoint.class, "stale",
                        type);

        SwitchPoint point = new SwitchPoint();
        MethodHandle guarded = point.guardWithTest(target, fallback);

        // 初始状态有效，因此这里绑定到 target。
        System.out.println((String) guarded.invokeExact("A"));
        SwitchPoint.invalidateAll(new SwitchPoint[]{point});

        // 同一个 point 已经失效，旧 guarded 永久走 fallback。
        System.out.println((String) guarded.invokeExact("B"));
        System.out.println(point.hasBeenInvalidated());
    }

    static String current(String value) {
        // 代表当前版本的处理逻辑。
        return "target:" + value;
    }

    static String stale(String value) {
        // 代表失效后的兜底逻辑。
        return "fallback:" + value;
    }
}

hasBeenInvalidated() 只能帮助你观察状态，不能把状态改回 valid。若业务层需要“再次启用”，问题不在于寻找一个隐藏的 reset 方法，而在于重新组装一组新的对象。

guardWithTest 绑定的是旧状态，不是动态配置名

另一个常见误区是把 target 看成一个会被 SwitchPoint 自动重新读取的配置槽位。实际上，guardWithTest 返回的是一个新的 guarded delegator，它和创建它的 SwitchPoint 建立了永久关联。

失效前，守卫的语义可以简化为“valid ? target : fallback”；失效后，它的稳定语义就是 fallback。即使你后来把业务配置、变量或某个新的 MethodHandle 改成了原来的样子，旧 guard 也不会因为变量内容变化而恢复。

因此排查时要区分两件事：

• 旧 guard 仍然走 fallback：这是旧 SwitchPoint 已经失效的正常表现。
• 新 guard 也走 fallback：要检查新实例是否真的创建成功、是否误用了旧实例，或新实例是否已经被再次失效。

新一轮状态要同时创建新实例和新守卫

重新启用的正确模型是“换代”，不是“复活”：保留旧 guard 作为旧状态的兜底引用，同时创建新的 SwitchPoint，再用它创建新的 guarded delegator。

import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.invoke.SwitchPoint;

public final class GuardRebuilder {
    private static final MethodType TYPE =
            MethodType.methodType(String.class, String.class);

    private GuardRebuilder() {
        // 工具类不需要实例化。
    }

    static MethodHandle build(MethodHandle target, MethodHandle fallback) {
        // target 与 fallback 类型不一致时，guardWithTest 会拒绝组合。
        SwitchPoint freshPoint = new SwitchPoint();
        return freshPoint.guardWithTest(target, fallback);
    }

    static MethodHandle newTarget() throws ReflectiveOperationException {
        // 每轮可以传入新的 target，但返回类型仍要与 fallback 对齐。
        return MethodHandles.lookup().findStatic(
                GuardRebuilder.class, "current", TYPE);
    }

    static String current(String value) {
        // 新一轮有效状态使用的处理逻辑。
        return "new-target:" + value;
    }
}

真实系统里，SwitchPoint 和对应的 guarded handle 通常要一起放进一个不可变状态对象，再由上层替换整个对象引用。不要只替换 target 变量，却继续把旧 guard 当成新入口。

target 和 fallback 必须保持同一方法类型

重建时最容易被忽略的不是状态，而是句柄签名。guardWithTest 要求 target 与 fallback 的方法类型完全一致，返回的组合句柄也使用这个类型。

例如 target 是 (String)String，fallback 也必须是 (String)String；不能让一个接收 String，另一个接收 Object，再期待守卫替你做适配。需要适配时，先用 asType 等方法显式得到同类型句柄，再组合。

// 统一两个处理分支的签名，避免组合时出现 IllegalArgumentException。
MethodType expected = MethodType.methodType(String.class, String.class);
MethodHandle target = loadTarget().asType(expected);
MethodHandle fallback = loadFallback().asType(expected);

// 新建实例表示新一轮有效状态，旧实例不参与复活。
SwitchPoint freshPoint = new SwitchPoint();
MethodHandle freshGuard = freshPoint.guardWithTest(target, fallback);

如果类型不匹配，应该先修正句柄的边界，而不是通过反复创建 SwitchPoint 掩盖问题。

批量失效时要注意哪些边界

invalidateAll(SwitchPoint[]) 是静态方法，适合一次把一组相关的点切到 invalid。它可能需要让其他线程同步感知状态变化，因此官方建议谨慎调用；如果有批量变更，可以合并后再处理。

传入数组或数组元素为 null 会抛出 NullPointerException。如果数组中途包含空元素，部分非空元素是否已经处理取决于实现，所以不要把“异常后重试同一个数组”当成无副作用操作。

// 只有确认数组内容完整时才批量失效，避免半批次状态难以解释。
SwitchPoint[] points = {userPoint, configPoint, routePoint};
SwitchPoint.invalidateAll(points);

// 下一轮要创建与新 guard 配套的新数组元素，而不是把旧元素改回有效。
SwitchPoint nextRoutePoint = new SwitchPoint();

排查“为什么还没恢复”的最短清单

1. 确认调用的是旧 guard 还是新 guard，先打印它们所属的状态对象标识。
2. 确认旧 SwitchPoint 是否已经执行过 invalidateAll，不要把 hasBeenInvalidated() 当成可写开关。
3. 确认新一轮确实创建了新的 SwitchPoint，而不是从旧状态对象中取回原实例。
4. 确认新 guard 的 target 与 fallback 方法类型完全相同。
5. 确认新 guard 已经替换到真正的调用入口，避免只在局部变量中完成重建。

记住这条判断就够了：同一个 SwitchPoint 只能从 valid 走向 invalid 一次；想让 target 再次参与选择，就必须用新实例和新 guard 建立新绑定。

相关问题

SwitchPoint 可以只调用一次 invalidateAll 吗？

可以。对已经失效的点重复调用没有恢复效果；业务上应把失效视为一次状态换代信号。

旧 guard 能不能通过重新传入 target 来更新？

不能。重新传入 target 只会创建另一个 guard；它不会修改已经返回的旧 guarded delegator。

什么时候适合批量调用 invalidateAll？

当多个 SwitchPoint 属于同一轮状态变更，并且可以接受一次性让它们全部失效时使用。若只改变一个对象，避免为了“刷新”而无差别批量失效。