Java 中的布尔表达式优化

发布于 2024-08-03 01:42:32 字数 770 浏览 4 评论 0原文

考虑 Java 中的以下方法：

public static boolean expensiveComputation() {
    for (int i = 0; i < Integer.MAX_VALUE; ++i);
    return false;
}

以及以下主要方法：

public static void main(String[] args) {
    boolean b = false;
    if (expensiveComputation() && b) {
    }
}

逻辑连接（与 && 相同）是交换运算。那么为什么编译器不将 if 语句代码优化为等效的：

if (b && expensiveComputation()) {
}

它具有使用短路评估的好处？

此外，编译器是否尝试进行其他逻辑简化或布尔值排列以生成更快的代码？如果没有，为什么？当然有些优化会很困难，但我的例子并不简单？调用方法应该总是比读取布尔值慢，对吧？

先感谢您。

原文

Consider the following method in Java:

public static boolean expensiveComputation() {
    for (int i = 0; i < Integer.MAX_VALUE; ++i);
    return false;
}

And the following main method:

public static void main(String[] args) {
    boolean b = false;
    if (expensiveComputation() && b) {
    }
}

Logical conjunction (same as &&) is a commutative operation. So why the compiler doesn't optimize the if-statement code to the equivalent:

if (b && expensiveComputation()) {
}

which has the benefits of using short-circuit evaluation?

Moreover, does the compiler try to make other logic simplifications or permutation of booleans in order to generate faster code? If not, why? Surely some optimizations would be very difficult, but my example isn't simple? Calling a method should always be slower than reading a boolean, right?

Thank you in advance.

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

尽揽少女心 2024-08-10 01:42:32

它不会这样做，因为昂贵的计算（）可能会产生改变程序状态的副作用。这意味着布尔语句中表达式的求值顺序（expenseComputation() 和 b）很重要。您不希望编译器将错误优化到已编译的程序中，对吗？

例如，如果代码是这样的

public static boolean expensiveComputation() {
        for (int i = 0; i < Integer.MAX_VALUE; ++i);
        b = false;
        return false;
}

public static boolean b = true;
public static void main(String[] args) {
        if (expensiveComputation() || b) {
        // do stuff
        }
}

，如果编译器执行了您的优化，那么 //do stuff 就会在您通过查看代码不期望它运行时运行（因为b，本来是真的，首先被评估）。

It doesn't do that because expensiveComputation() may have side effects which change the state of the program. This means that the order in which the expressions in the boolean statements are evaluated (expensiveComputation() and b) matters. You wouldn't want the compiler optimizing a bug into your compiled program, would you?

For example, what if the code was like this

public static boolean expensiveComputation() {
        for (int i = 0; i < Integer.MAX_VALUE; ++i);
        b = false;
        return false;
}

public static boolean b = true;
public static void main(String[] args) {
        if (expensiveComputation() || b) {
        // do stuff
        }
}

Here, if the compiler performed your optimization, then the //do stuff would run when you wouldn't expect it to by looking at the code (because the b, which is originally true, is evaluated first).

回复收藏 0 原文