Question

此：

if (var) {
    var = false;
}

对此：

var = false;

是否存在速度差异？

Answer 1

有几件事情发挥作用，对实际性能的最终影响是您需要根据用例来衡量的。我认为这是你发现的一种方法很多：

分支预测 - 如果var几乎总是假的，这就是代码所暗示的，分支预测器几乎总是正确的。如果该字段经常变化，那么这将成为一个经常被错误预测的分支并且将是昂贵的。
读取未命中 - 如果var主要是读取（并且读取很多），那么避免无故更改可以帮助您的软件不会使其所在的缓存行无效。如果你写它，每个读取它的核心（以及同一个缓存行上的任何内容）都需要获得一个新的副本来体验读取错过。这意味着为了使读取具有更加一致的速度，上述方法可能值得慢一些。
写入成本与读取成本 - 如果var是易失性的，那么它的写入是一个非常昂贵的LoadStore屏障。相比之下，读取volatile（一个LoadLoad屏障）是相当便宜的（对于经常使用且几乎没有改变的值的缓存命中）。相比之下，这可以使分支非常便宜。

这是人们的优化，可以在JDK（IIRC）中找到示例，我假设您有理由考虑它。

Answer 2

第一个代码包含一个比较，因此您的编译器可能会生成一个类似于以下内容的java字节码：

  public static void main(java.lang.String[]);
    Code:
       0: iconst_1      
       1: istore_1      
       2: iload_1       
       3: ifeq          8
       6: iconst_0      
       7: istore_1      
       8: return

对于第二个代码，生成的字节码较短，因为缺少比较：

  public static void main(java.lang.String[]);
    Code:
       0: iconst_1      
       1: istore_1      
       2: iconst_0      
       3: istore_1      
       4: return

虚拟机在第一个示例中需要更多时间来执行8个命令，而在第二个示例中需要4个命令。虽然这种差异不应该高，但第二个代码更清楚。

将代码放在一个简单的main方法中并编译该类。然后运行命令提示符并切换到java/bin目录。要反汇编课程javap -c path/to/YourClass.class >> path/to/bytecode.txt。 bytecode.txt将包含您类的java字节码。

Answer 3

我在这个游戏上迟到了，但是我写了这个测试课来回答类似的问题。

package SpeedTests;

import java.text.NumberFormat;
import java.util.Locale;

public class BooleanSpeedTest {

    public static void main(String[] args) {
        boolean BoolTest = true;
        long LongLoop = 100000;
        long TrueLoopCount = 0;
        long FalseLoopCount = 0;
        long TimeTotal = 0;

        long startTime;
        long endTime;

        for(int intLoopA = 1; intLoopA < 6; intLoopA++) {
            LongLoop = LongLoop * 10;
            TimeTotal = 0;
            System.out.println("");
            System.out.print(
                    NumberFormat.getNumberInstance(Locale.US).format(LongLoop) + " - ");

            for(int intLoopM = 0; intLoopM < 20; intLoopM++) {
                TrueLoopCount = 0;
                FalseLoopCount = 0;
                startTime = System.currentTimeMillis();

                for(long LoopCount = 0; LoopCount < LongLoop; LoopCount++) {
                    if(!BoolTest) {
                        TrueLoopCount++;
                    }
                    else
                        FalseLoopCount++;   
                }
                endTime = System.currentTimeMillis();
                System.out.print( (endTime - startTime) + "ms ");
                TimeTotal += ((endTime - startTime) );    
            }

            System.out.print(" AVG: " + (TimeTotal/20));
        }
    }
}

我的结果：平均时间/十亿（ms）每个循环的笔记时间

if(BoolTest)                    443                     When False      0.00000443
if(BoolTest)                    443                     When True

if(BoolTest == false)           443                     When False
if(BoolTest == false)           442                     When True

if(!BoolTest)                   438                     When False      
if(!BoolTest)                   441                     When True

(BoolTest ? Var++ : Var--)      435                     When True
(BoolTest ? Var++ : Var--)      435                     When False

Answer 4

这是另一个廉价的“基准”（几乎不值得使用该术语）。对我而言，Monkey Wrench的基准测试结果并未明确提及OP的问题，因此我认为我也应该将其放在此处。

结果（在这种情况下，并且仅进行了很少的测试）：在编写局部布尔值之前，最好检查它，而不是在不需要时经常编写它。

public static void main(String[] args) {

    final Random r = new Random(0);

    boolean b = false;
    boolean decision;

    long startTime;
    long endTime;

    startTime = System.currentTimeMillis();
    for (long i = 0; i < 1000000000; i++) {
        decision = r.nextDouble() > 0.1; // Will be true MOST of the time.

        if (decision) {

            // if (!b) {
                b = true;
            // }

        }
    }
    endTime = System.currentTimeMillis();

    System.err.println(endTime - startTime);
    System.err.println(b);

    System.exit(0);
}

With bluntly writing (ms):
18139
18140
18196
(18220)
(18181)
----------
Average of 3: 18158.333333333333333333333333333
Average of 5: 18175.2


With checking before writing (ms):
18097
18109
18115
(18129)
(18133)
----------
Average of 3: 18107
Average of 5: 18116.6


With checking, it only takes this % (3 samples): 99.71730151445617255621844882974
With checking, it only takes this % (5 samples): 99.677582640080989480170782164708

通过检查，大约花费了99.7％的钝写时间。如果写入可能会不必要 非常频繁。在这个卑鄙的“基准”中，就是这样。

Answer 5

＆＃34;速度差异，＆＃34;如果有的话，完全取决于JVM。任何体面的编译器都应该能够优化测试，此时两者是相同的。

异常：如果声明var为volatile，则条件版本将始终较慢。

在任何情况下，如果性能至关重要，最好的选择是在预期条件下（机器，系统，JVM，典型负载等）测量。

检查布尔值比在java中设置布尔值更快？

5 个答案: