在字节码级别，Java boolean 值表示为 0 或 1。我有一个结果为 0 或 1 的表达式，但它是用 int 类型计算的。一个简单的例子是:

public static int isOdd_A(int value) {
    return value & 1;
}

public static boolean isOdd_B(int value) {
    return (value & 1) == 1;
}

上述方法的字节码如下所示:

  public static int isOdd_A(int);
    descriptor: (I)I
    Code:
       0: iload_0
       1: iconst_1
       2: iand
       3: ireturn

  public static boolean isOdd_B(int);
    descriptor: (I)Z
    Code:
       0: iload_0
       1: iconst_1
       2: iand
       3: iconst_1
       4: if_icmpne     11
       7: iconst_1
       8: goto          12
      11: iconst_0
      12: ireturn

返回 boolean 值的方法要大得多并且包含一个分支，因此如果运行的机器代码是等效的，则它不是最优的。

HotSpot JVM 会知道 boolean 版本可以优化为无分支机器代码吗？有没有办法诱骗 Java 将基于 int 的字节代码用于返回 boolean 值的方法(例如使用 ASM)？

编辑: 许多人认为这不值得担心，总的来说我同意。然而，我确实创建了这个微型基准测试并使用 jmh 运行它，并注意到 int 版本的改进大约为 10%:

@Benchmark
public int countOddA() {
    int odds = 0;
    for (int n : numbers)
        if (Test.isOdd_A(n) == 1)
            odds++;
    return odds;
}
@Benchmark
public int countOddB() {
    int odds = 0;
    for (int n : numbers)
        if(Test.isOdd_B(n))
            odds++;
    return odds;
}

Benchmark                Mode  Cnt      Score    Error  Units
OddBenchmark.countOddA  thrpt  100  18393.818 ± 83.992  ops/s
OddBenchmark.countOddB  thrpt  100  16689.038 ± 90.182  ops/s

我同意代码应该是可读的(这就是为什么我想要具有适当 boolean 接口(interface)的无分支 int 版本的性能)，并且大多数时候这种优化级别是没有必要的。然而，在这种情况下，即使所讨论的方法甚至不占代码的大部分，也有 10% 的 yield 。

因此，也许我们这里的情况是 HotSpot 可以意识到这种模式并生成更好的代码。

最佳答案

首先，10% 不是一个值得付出任何努力的速度差异。

请注意，显式转换为零或一仅在对 boolean 进行显式赋值时发生(其中包括声明为返回 boolean< 的方法的="">return 语句)。当表达式是条件或复合 boolean 表达式的一部分时，这不会发生，例如

static boolean isOddAndShort(int i) {
    return (i&1)!=0 && (i>>>16)==0;
}

编译为

static boolean isOddAndShort(int);
descriptor: (I)Z
flags: ACC_STATIC
Code:
  stack=2, locals=1, args_size=1
     0: iload_0
     1: iconst_1
     2: iand
     3: ifeq          17
     6: iload_0
     7: bipush        16
     9: iushr
    10: ifne          17
    13: iconst_1
    14: goto          18
    17: iconst_0
    18: ireturn

如您所见，在and 操作之前，这两个表达式并没有转换为零或一，只是最终结果。

同样

static void evenOrOdd(int i) {
    System.out.println((i&1)!=0? "odd": "even");
}

编译为

static void evenOrOdd(int);
descriptor: (I)V
flags: ACC_STATIC
Code:
  stack=3, locals=1, args_size=1
     0: getstatic     #2        // Field java/lang/System.out:Ljava/io/PrintStream;
     3: iload_0
     4: iconst_1
     5: iand
     6: ifeq          14
     9: ldc           #3        // String odd
    11: goto          16
    14: ldc           #4        // String even
    16: invokevirtual #5        // Method java/io/PrintStream.println:(Ljava/lang/String;)V
    19: return

不承担任何到零或一的转换。

(请注意，此处与零进行比较利用了有关i&1 返回零或一的知识，这比与一进行比较更好)。

所以当我们谈论，例如实际应用程序代码的 0.01%(或更少)并假设该特定代码加速 10%，我们可以预期整体速度提高 0.001%(或更少)。

仍然，只是为了好玩或作为一个小的代码压缩功能(可能作为更通用的代码压缩或字节码混淆的一部分)，这里是一个基于 ASM 的解决方案:

为了使转换更容易，我们定义了一个占位符方法，i2b 执行一个 int 到 boolean 的转换，并在预定地点。转换器简单地删除了方法声明及其调用:

public class Example {
    private static boolean i2b(int i) {
        return i!=0;
    }
    public static boolean isOdd(int i) {
        return i2b(i&1);
    }
    public static void run() {
        for(int i=0; i<10; i++)
            System.out.println(i+": "+(isOdd(i)? "odd": "even"));
    }
}

public class Int2Bool {
    public static void main(String[] args) throws IOException {
        String clName = Example.class.getName();
        ClassReader cr = new ClassReader(clName);
        ClassWriter cw = new ClassWriter(cr, 0);
        cr.accept(new ClassVisitor(Opcodes.ASM5, cw) {
            @Override
            public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
                if(name.equals("i2b") && desc.equals("(I)Z")) return null;
                return new MethodVisitor(Opcodes.ASM5, super.visitMethod(access, name, desc, signature, exceptions)) {
                    @Override
                    public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
                        if(opcode == Opcodes.INVOKESTATIC && name.equals("i2b") &&  desc.equals("(I)Z"))
                            return;
                        super.visitMethodInsn(opcode, owner, name, desc, itf);
                    }
                };
            }
        }, 0);
        byte[] code = cw.toByteArray();
        if(writeBack(clName, code))
            Example.run();
        else
            runDynamically(clName, code);
    }
    private static boolean writeBack(String clName, byte[] code) {
        URL u = Int2Bool.class.getResource("/"+clName.replace('.', '/')+".class");
        if(u==null || !u.getProtocol().equals("file")) return false;
        try {
            Files.write(Paths.get(u.toURI()), code, StandardOpenOption.TRUNCATE_EXISTING);
            return true;
        } catch(IOException|URISyntaxException ex) {
            ex.printStackTrace();
            return false;
        }
    }

    private static void runDynamically(String clName, byte[] code) {
        // example run
        Class<?> rtClass = new ClassLoader() {
            Class<?> get() { return defineClass(clName, code, 0, code.length); }
        }.get();
        try {
            rtClass.getMethod("run").invoke(null);
        } catch (ReflectiveOperationException ex) {
            ex.printStackTrace();
        }
    }
}

转换后的方法看起来像

public static boolean isOdd(int);
descriptor: (I)Z
flags: ACC_PUBLIC, ACC_STATIC
Code:
  stack=2, locals=1, args_size=1
     0: iload_0
     1: iconst_1
     2: iand
     3: ireturn

并且工作没有问题。但如前所述，这只是一个练习，没有太大的实际值(value)。

关于java - 我有一个返回 0 或 1 的 Java 方法。我可以让它返回一个 boolean 值而不生成分支指令吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/48526661/