我很好奇Java如何对具有互斥条件的多个“if”语句进行优化，但我没有自己分析它的知识。问题基本上是this question的Java版本“if if”与“if else if”的性能差异
我已经看到这回答了if语句return，但这个问题是针对if具有互斥条件但不返回的语句。
1.多个if语句
if (x == 0) doSomething();
if (x == 2) doSomething();
if (x == 5) doSomething();
2. 链式 If-else 语句
if (x == 0) doSomething();
else if (x == 2) doSomething();
else if (x == 5) doSomething();
问题
#1 和#2 执行相同的后编译吗？
（另外：如果是这样，Java 可以优化多复杂的条件？）
没有什么比一个好的老式时序测试更好的了：
long total = 0;
long startTime;
long endTime;
for (int j = 0; j < 10; j++) {
startTime = System.currentTimeMillis();
for (int i = 0; i < 100000000; i++) {
if (i % 3 == 0) total += 1;
if (i % 3 == 1) total += 2;
if (i % 3 == 2) total += 3;
}
endTime = System.currentTimeMillis();
System.out.println("If only: " + (endTime - startTime));
startTime = System.currentTimeMillis();
for (int i = 0; i < 100000000; i++) {
if (i % 3 == 0) total += 1;
else if (i % 3 == 1) total += 2;
else if (i % 3 == 2) total += 3;
}
endTime = System.currentTimeMillis();
System.out.println("If-else: " + (endTime - startTime));
}
System.out.println(total);
（“总”值是防止编译器删除整个循环所必需的！）
输出：
If only: 215
If-else: 137
If only: 214
If-else: 121
If only: 210
If-else: 120
If only: 211
If-else: 120
If only: 211
If-else: 121
If only: 210
If-else: 121
If only: 210
If-else: 121
If only: 211
If-else: 120
If only: 211
If-else: 120
If only: 211
If-else: 121
3999999980
正如我们所看到的，即使 if 条件显然是互斥的，if-else 块的运行速度也明显更快。由于两个循环所用的时间长度不同，因此每个循环的编译代码必须不同。显然编译器没有对此进行优化。JIT 或 CPU 也不完全分支预测。还是有很大区别的。
我的建议：尽可能使用 If-else
编辑：我也尝试交换两个循环并得到相同的结果。If-else if 更快。
编辑 2：我在整个测试中添加了一个 for 循环，以消除初始化或预热中的任何差异。结果是一样的。
有一点不同，虽然很小。关键问题是该过程的任何步骤是否由足够智能的软件完成，以推断 if x==0、 thenx==2和x==5一定是假的。
在 Java 字节码级别，它们通常会产生不同的结果。编译器没有义务足够聪明地分析差异。（Eugene 对相关问题的回答表明 Sun 的 Java 12 编译器确实足够聪明，可以在某些情况下为您进行这种优化）
及时编译器往往相当激进。他们更有可能意识到代码只能流经三个分支之一并将其优化掉。但这仍然是一个依赖于工具的声明。Java 语言本身将它们视为不同的。
现在，实际上，除非您进行非常紧密的循环，否则这一点都不重要。优化中的第一条规则是“配置文件，然后优化”。在至少 99% 的情况下，没有理由优化这些细节。
具体来说，在您给出的示例中，即使编译器和 JIT 无法为您优化代码，性能成本也可以忽略不计。doSomething()在“平均”CPU 上，成功预测的分支大约是函数调用成本的十分之一，因此您在这些分支上调用的事实将使成本相形见绌。如果额外的调用导致一些额外的分支错误预测，您可能会看到更糟糕的效果，但没有什么比调用函数更昂贵的了。
现在，假设这doSomething()实际上是类似 快的东西的占位符x += 1，那么您需要分析以确定它是否正确。
所以，我的建议是写if/if/if或if/else if/else if基于任何一个是正确的。对于您要使用的逻辑，哪个最有意义就是正确的答案。如果这打算成为一个只采用一条路径的分支，我建议else if. 如果这是一个函数可能在未来执行许多分支的情况，但恰好当前分支列表是互斥的，请if/if/if向读者传达预期的结果。
然后简介。始终配置文件。如果您发现此函数是热点，请考虑担心 if 语句是否昂贵。
顺便说一句，编译器很难证明它们可以转换if为else if. 它必须对 x 进行分析，看看是否有可能被另一个线程修改。如果它是一个局部变量，其他线程不能修改它。但是，如果它是成员变量，则另一个线程可能会x在您的块中间进行修改if/if/if，从而导致它采用两条路径。你可能知道没有其他人会x这样修改，但编译器在进行这样的优化之前必须证明这一点，或者至少证明它所写的内容与其对 Java 内存模型规则的实现一致。
好吧，只有适当的 JMH 测试才能证明某种方法的速度有多快。当然，需要注意的是，如果您真的想知道为什么数字是这样的，您还应该了解底层的机器代码。我把它留给你，只是在这个测试中展示数字，只是稍微向你展示一些细节。
package com.so;
import java.util.concurrent.TimeUnit;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Warmup;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
@Warmup(iterations = 5)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Measurement(iterations = 2, time = 2, timeUnit = TimeUnit.SECONDS)
public class IfElseCompare {
public static void main(String[] args) throws Exception {
Options opt = new OptionsBuilder()
.include(IfElseCompare.class.getName())
.jvmArgs("-ea")
.build();
new Runner(opt).run();
}
private int resolveValueMultipleIfs(IfElseExecutionPlan plan) {
int x = -1;
if (plan.value() == 0) {
x = 0;
}
if (plan.value() == 1) {
x = 1;
}
if (plan.value() == 2) {
x = 2;
}
assert x != -1;
return x;
}
private int resolveValueIfElse(IfElseExecutionPlan plan) {
int x = -1;
if (plan.value() == 0) {
x = 0;
} else if (plan.value() == 1) {
x = 1;
} else if (plan.value() == 2) {
x = 2;
}
assert x != -1;
return x;
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@Fork(1)
public int multipleIf(IfElseExecutionPlan plan) {
return resolveValueMultipleIfs(plan);
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@Fork(1)
public int ifElse(IfElseExecutionPlan plan) {
return resolveValueIfElse(plan);
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@Fork(value = 1, jvmArgsAppend = "-Xint")
public int multipleIfsfNoJIT(IfElseExecutionPlan plan) {
return resolveValueMultipleIfs(plan);
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@Fork(value = 1, jvmArgsAppend = "-Xint")
public int ifElseNoJIT(IfElseExecutionPlan plan) {
return resolveValueIfElse(plan);
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@Fork(value = 1, jvmArgsAppend = "-XX:-TieredCompilation")
public int multipleIfsC2Only(IfElseExecutionPlan plan) {
return resolveValueMultipleIfs(plan);
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@Fork(value = 1, jvmArgsAppend = "-XX:-TieredCompilation")
public int ifElseC2Only(IfElseExecutionPlan plan) {
return resolveValueIfElse(plan);
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@Fork(value = 1, jvmArgsAppend = "-XX:TieredStopAtLevel=1")
public int multipleIfsC1Only(IfElseExecutionPlan plan) {
return resolveValueMultipleIfs(plan);
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@Fork(value = 1, jvmArgsAppend = "-XX:TieredStopAtLevel=1")
public int ifElseC1Only(IfElseExecutionPlan plan) {
return resolveValueIfElse(plan);
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@Fork(value = 1,
jvmArgsAppend = {
"-XX:+UnlockExperimentalVMOptions",
"-XX:+EagerJVMCI",
"-Dgraal.ShowConfiguration=info",
"-XX:+UseJVMCICompiler",
"-XX:+EnableJVMCI"
})
public int multipleIfsGraalVM(IfElseExecutionPlan plan) {
return resolveValueMultipleIfs(plan);
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@Fork(value = 1,
jvmArgsAppend = {
"-XX:+UnlockExperimentalVMOptions",
"-XX:+EagerJVMCI",
"-Dgraal.ShowConfiguration=info",
"-XX:+UseJVMCICompiler",
"-XX:+EnableJVMCI"
})
public int ifElseGraalVM(IfElseExecutionPlan plan) {
return resolveValueIfElse(plan);
}
}
结果如下：
IfElseCompare.ifElse avgt 2 2.826 ns/op
IfElseCompare.multipleIf avgt 2 3.061 ns/op
IfElseCompare.ifElseC1Only avgt 2 3.927 ns/op
IfElseCompare.multipleIfsC1Only avgt 2 4.397 ns/op
IfElseCompare.ifElseC2Only avgt 2 2.507 ns/op
IfElseCompare.multipleIfsC2Only avgt 2 2.428 ns/op
IfElseCompare.ifElseGraalVM avgt 2 2.587 ns/op
IfElseCompare.multipleIfsGraalVM avgt 2 2.854 ns/op
IfElseCompare.ifElseNoJIT avgt 2 232.418 ns/op
IfElseCompare.multipleIfsfNoJIT avgt 2 303.371 ns/op
如果反编译有多个if条件的版本：
0x000000010cf8542c: test %esi,%esi
0x000000010cf8542e: je 0x000000010cf8544f ;*ifne {reexecute=0 rethrow=0 return_oop=0}
; - com.so.IfElseCompare::resolveValueMultipleIfs@3 (line 21)
0x000000010cf85430: cmp $0x1,%esi
0x000000010cf85433: je 0x000000010cf8545e ;*if_icmpne {reexecute=0 rethrow=0 return_oop=0}
; - com.so.IfElseCompare::resolveValueMultipleIfs@10 (line 25)
0x000000010cf85435: cmp $0x2,%esi
0x000000010cf85438: je 0x000000010cf8546e ;*if_icmpne {reexecute=0 rethrow=0 return_oop=0}
; - com.so.IfElseCompare::resolveValueMultipleIfs@17 (line 29)
一系列cmp/je- 比较和如果相等则跳转，嗯，非常期待。
反编译出来的代码if/else是一样的（我让你反编译亲眼看看）；使用 (java-12) 生成的 ASM 代码：
java -XX:+UnlockDiagnosticVMOptions
-XX:CICompilerCount=2
-XX:-TieredCompilation
"-XX:CompileCommand=print,com/so/IfElseCompare.resolveValueMultipleIfs"
com.so.IfElseCompare
让我告诉你条件运算符“if()”是如何工作的。当您编写 if() 语句时，它会检查您在这些“()”中提供的条件的真实性。如果条件失败，则编译器会寻找可在 if() 条件失败时使用的替代语句或代码块。现在对于这个替代内容，我们使用“else”块。
现在根据你的问题，答案很容易理解。两种方式都有很大的不同。
1）。多个 If 语句
if (x == 0) doSomething();
if (x == 2) doSomething();
if (x == 5) doSomething();
在上面的代码中，无论是否满足任何条件，编译器都会解析所有 if 语句。因为它们是单独使用的，没有任何替代部分。
2）。链式 If-else 语句
if (x == 0) doSomething();
else if (x == 2) doSomething();
else if (x == 5) doSomething();
现在在上面的代码中，现在有一个主要的条件检查器(x==0)，如果失败了，那么还有其他替代方案存在，因此编译器将检查它们，直到找到满意的解决方案。
性能问题
在第一种情况下，编译器必须检查每个条件，因为它们都是独立的，这可能需要更多时间。但在第二种情况下，它只会在 if() 语句不满足条件时编译“else if”部分。所以是的，在性能方面它们之间可能会有一点差异。
我希望它有所帮助。