为何分支预测比枚举中的函数调用更快？benchEnum性能疑问

我完全理解benchIfAndSwitch因分支预测机制比benchSwitch性能更优，但疑惑未使用if或switch语句的benchEnum为何不是性能最快的？以下是我的测试代码及基准测试结果（含移除try-catch前后的结果），恳请解答：

测试代码 #

public class TestBenchMarks {
    public enum ChannelState {
        CONNECTED, DISCONNECTED, SENT, RECEIVED, CAUGHT
    }

    @State(Scope.Benchmark)
    public static class ExecutionPlan {
        @Param({ "100000" })
        public int size;
        public ChannelState[] states = null;

        public ChannelState2[] states2 = null;

        @Setup
        public void setUp() {
            ChannelState[] values = ChannelState.values();
            states = new ChannelState[size];
            Random random = new Random(new Date().getTime());

            for (int i = 0; i < 100000; i++) {
                int nextInt = random.nextInt(1000000);
                if (nextInt > 100) {
                    states[i] = ChannelState.CONNECTED;
                } else {
                    states[i] = values[nextInt % values.length];
                }
            }

            ChannelState2[] values2 = ChannelState2.values();
            states2 = new ChannelState2[size];
            for (int i = 0; i < 100000; i++) {
                if (i > 100) {
                    states2[i] = ChannelState2.CONNECTED;
                } else {
                    states2[i] = values2[i % values2.length];
                }
            }
        }
    }

    @Fork(value = 5)
    @Benchmark
    @BenchmarkMode(Mode.Throughput)
    public void benchSwitch(ExecutionPlan plan, Blackhole bh) {
        int result = 0;
        for (int i = 0; i < plan.size; ++i) {
            switch (plan.states[i]) {
            case CONNECTED:
                result += 1;
                break;
            case DISCONNECTED:
                result += 1;
                break;
            case SENT:
                result += 1;
                break;
            case RECEIVED:
                result += 1;
                break;
            case CAUGHT:
                result += 1;
                break;
            }
        }
        bh.consume(result);
    }

    @Fork(value = 5)
    @Benchmark
    @BenchmarkMode(Mode.Throughput)
    public void benchIfAndSwitch(ExecutionPlan plan, Blackhole bh) {
        int result = 0;
        for (int i = 0; i < plan.size; ++i) {
            ChannelState state = plan.states[i];
            if (state == ChannelState.CONNECTED) {
                result += 1;
            } else {
                switch (state) {
                case RECEIVED:
                    result += 1;
                    break;
                case SENT:
                    result += 1;
                    break;
                case DISCONNECTED:
                    result += 1;
                    break;
                case CAUGHT:
                    result += 1;
                    break;
                }
            }
        }
        bh.consume(result);
    }

    @Fork(value = 5)
    @Benchmark
    @BenchmarkMode(Mode.Throughput)
    public void benchEnum(ExecutionPlan plan, Blackhole bh) {
        int result = 0;
        for (int i = 0; i < plan.size; ++i) {
            plan.states2[i].handle(result);
        }
        bh.consume(result);
    }


    public enum ChannelState2 {

        /**
         * CONNECTED
         */
        CONNECTED((int a) -> {
            try {
                a = a + 1;

            } catch (Exception e) {
                e.printStackTrace();
            }
        }),

        /**
         * DISCONNECTED
         */
        DISCONNECTED((int a) -> {
            try {
                a = a + 1;
            } catch (Exception e) {
                e.printStackTrace();
            }
        }),

        /**
         * SENT
         */
        SENT((int a) -> {
            try {
                a = a + 1;
            } catch (Exception e) {
                e.printStackTrace();
            }
        }),

        /**
         * RECEIVED
         */
        RECEIVED((int a) -> {
            try {
                a = a + 1;
            } catch (Exception e) {
                e.printStackTrace();
            }
        }),

        /**
         * CAUGHT
         */
        CAUGHT((int a) -> {
            try {
                a = a + 1;
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        private final HandlerFunction function;

        ChannelState2(HandlerFunction handleFunction) {
            this.function = handleFunction;
        }

        private void handle(int a) {
            function.handle(a);
        }
    }

    private interface HandlerFunction {
        void handle(int a);
    }
}

基准测试结果 #

初始测试（含try-catch） #

移除try-catch后测试 #

benchEnum未使用显式分支却性能落后，核心原因可归纳为以下几点：

1. 额外的方法调用开销 #

benchEnum的循环中每次都要执行两层方法调用：枚举的handle方法，以及其内部的HandlerFunction接口方法（lambda实现）。尽管JVM的JIT编译器会尝试内联这些调用，但相比benchSwitch和benchIfAndSwitch直接在循环内执行result +=1的逻辑，方法调用的分派、栈帧操作仍会带来不可忽视的额外开销，在百万级循环下会被显著放大。

2. 参数传递的逻辑缺陷（限制JIT优化） #

你的benchEnum存在关键逻辑错误：handle方法接收的int a是值传递，lambda里的a = a +1仅修改局部变量，完全不会影响外部的result变量。这意味着整个循环中result始终为0，JVM会识别到这是无意义的计算，优化策略会与另外两个有实际累加逻辑的用例不同——后两者的result最终等于循环次数，JVM可以进行激进的循环展开、常量折叠等优化，而benchEnum因无实际状态修改，优化空间被大幅限制。

3. try-catch块的性能损耗 #

初始测试中benchEnum的lambda包含try-catch块，即便没有异常抛出，JVM也需要维护异常表、处理栈帧的异常检查逻辑，这会阻碍JIT的部分优化（例如无法内联包含try-catch的代码）。移除try-catch后性能明显提升，也验证了这一点，但方法调用和逻辑缺陷的影响依然存在，因此性能仍落后于前两个用例。

4. 间接分支的预测效率问题 #

benchIfAndSwitch性能最优是因为它利用了分支预测：绝大多数数据是CONNECTED，第一个if判断会被预测为命中，直接执行累加，极少进入switch分支。而benchEnum虽然没有显式分支，但方法调用的动态分派本身会带来间接分支（JVM需确定调用哪个lambda实现），且这种分支的可预测性远不如显式if判断，分支预测效率更低。

内容的提问来源于stack exchange，提问作者FressMonster