在Java中使用final关键字是否可以提高性能？

在Java中，我们看到了很多final可以使用关键字但很少使用的地方。

例如：

String str = "abc";
System.out.println(str);

在上述情况下，str可以，final但是通常不这样做。

当一个方法永远不会被覆盖时，我们可以使用final关键字。类似地，对于不会被继承的类。

在任何或所有这些情况下使用final关键字是否真的可以提高性能？如果是这样，那又如何？请解释。如果final对性能的正确使用确实很重要，那么Java程序员应该养成什么习惯来充分利用关键字？

通常不会。对于虚拟方法，HotSpot会跟踪该方法是否已被实际覆盖，并能够执行优化，例如在未覆盖方法的前提下进行内联-直到它加载了覆盖该方法的类为止。它可以撤消（或部分撤消）那些优化。

（当然，这是假设您使用的是HotSpot-但这是迄今为止最常见的JVM，所以...）

我认为您应该final基于清晰的设计和可读性而不是出于性能原因而使用。如果出于性能原因要进行任何更改，则应在弯曲最清晰的代码之前进行适当的测量-这样，您可以确定所实现的任何额外性能是否值得较差的可读性/设计。（根据我的经验，这几乎是不值得的； YMMV。）

编辑：正如最后提到的领域，值得一提的是，就清晰的设计而言，它们通常还是个好主意。它们还改变了跨线程可见性的保证行为：构造函数完成后，可以保证任何final字段都立即在其他线程中可见。这可能是final我经验中最常见的用法，尽管作为乔什·布洛赫（Josh Bloch）的“继承设计或禁止继承设计”经验法则的支持者，我可能应该final更频繁地在类上使用它。

简短的答案：不用担心！

长答案：

在讨论最终局部变量时，请记住，使用关键字final将有助于编译器静态优化代码，最终可能会导致代码更快。例如，以下示例中的最终String a + b是静态连接的（在编译时）。

public class FinalTest {

    public static final int N_ITERATIONS = 1000000;

    public static String testFinal() {
        final String a = "a";
        final String b = "b";
        return a + b;
    }

    public static String testNonFinal() {
        String a = "a";
        String b = "b";
        return a + b;
    }

    public static void main(String[] args) {
        long tStart, tElapsed;

        tStart = System.currentTimeMillis();
        for (int i = 0; i < N_ITERATIONS; i++)
            testFinal();
        tElapsed = System.currentTimeMillis() - tStart;
        System.out.println("Method with finals took " + tElapsed + " ms");

        tStart = System.currentTimeMillis();
        for (int i = 0; i < N_ITERATIONS; i++)
            testNonFinal();
        tElapsed = System.currentTimeMillis() - tStart;
        System.out.println("Method without finals took " + tElapsed + " ms");

    }

}

结果？

Method with finals took 5 ms
Method without finals took 273 ms

在Java Hotspot VM 1.7.0_45-b18上测试。

那么实际的性能提高了多少？我不敢说 在大多数情况下，这可能是微不足道的（在这种综合测试中约为270纳秒，因为完全避免了字符串连接，这是一种罕见的情况），但是在高度优化的实用程序代码中，这可能是一个因素。无论如何，对原始问题的回答是肯定的，它可能会提高性能，但充其量只能达到一点点。

除了编译时的好处，我找不到任何证据表明使用关键字final对性能有任何可衡量的影响。

是的，它可以。这是final可以提高性能的一个实例：

条件编译是一种不根据特定条件将代码行编译到类文件中的技术。这可用于删除生产版本中的大量调试代码。

考虑以下：

public class ConditionalCompile {

  private final static boolean doSomething= false;

    if (doSomething) {
       // do first part. 
    }

    if (doSomething) {
     // do second part. 
    }

    if (doSomething) {     
      // do third part. 
    }

    if (doSomething) {
    // do finalization part. 
    }
}

通过将doSomething属性转换为最终属性，您已经告诉编译器，只要编译器看到doSomething，就应按照编译时替换规则将其替换为false。编译器的第一遍改变代码的东西是这样的：

public class ConditionalCompile {

  private final static boolean doSomething= false;

    if (false){
       // do first part. 
    }

    if (false){
     // do second part. 
    }

    if (false){
      // do third part. 
    }

    if (false){
    // do finalization part. 

    }
}

完成此操作后，编译器会再次查看它，并发现代码中存在无法访问的语句。由于您使用的是高质量的编译器，因此它不喜欢所有那些无法访问的字节码。因此，它将它们删除，您最终得到以下结果：

public class ConditionalCompile {


  private final static boolean doSomething= false;

  public static void someMethodBetter( ) {

    // do first part. 

    // do second part. 

    // do third part. 

    // do finalization part. 

  }
}

从而减少了过多的代码或任何不必要的条件检查。

编辑：作为示例，让我们采用以下代码：

public class Test {
    public static final void main(String[] args) {
        boolean x = false;
        if (x) {
            System.out.println("x");
        }
        final boolean y = false;
        if (y) {
            System.out.println("y");
        }
        if (false) {
            System.out.println("z");
        }
    }
}

当使用Java 8编译此代码并进行反编译时，javap -c Test.class我们得到：

public class Test {
  public Test();
    Code:
       0: aload_0
       1: invokespecial #8                  // Method java/lang/Object."<init>":()V
       4: return

  public static final void main(java.lang.String[]);
    Code:
       0: iconst_0
       1: istore_1
       2: iload_1
       3: ifeq          14
       6: getstatic     #16                 // Field java/lang/System.out:Ljava/io/PrintStream;
       9: ldc           #22                 // String x
      11: invokevirtual #24                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      14: iconst_0
      15: istore_2
      16: return
}

我们可以注意到，编译后的代码仅包含非最终变量x。这证明，至少对于这种简单情况，最终变量会影响性能。

根据IBM-它不适用于类或方法。

http://www.ibm.com/developerworks/java/library/j-jtp04223.html

令我惊讶的是，没有人实际发布过一些经过反编译的真实代码，以证明至少存在一些细微的差异。

对于参考这已经对测试javac版本8，9和10。

假设此方法：

public static int test() {
    /* final */ Object left = new Object();
    Object right = new Object();

    return left.hashCode() + right.hashCode();
}

按原样编译此代码，将产生与出现时完全相同的字节代码final（final Object left = new Object();）。

但是这个：

public static int test() {
    /* final */ int left = 11;
    int right = 12;
    return left + right;
}

产生：

   0: bipush        11
   2: istore_0
   3: bipush        12
   5: istore_1
   6: iload_0
   7: iload_1
   8: iadd
   9: ireturn

离开final会产生：

   0: bipush        12
   2: istore_1
   3: bipush        11
   5: iload_1
   6: iadd
   7: ireturn

该代码几乎是不言自明的，如果有一个编译时间常数，它将直接加载到操作数堆栈上（它不会像前面的示例一样通过via存入本地变量数组中bipush 12; istore_0; iload_0）-这很有意义因为没有人可以改变它。

另一方面，为什么在第二种情况下编译器没有产生istore_0 ... iload_0超出我的范围，这并不是像0以任何方式使用该插槽（它可能以这种方式缩小变量数组，但可能是我缺少了一些内部细节，无法肯定地说）

考虑到这种优化很少，我很惊讶javac。至于我们应该经常使用final吗？我什至不打算编写一个JMH测试（我最初想写一个测试），我确信差异在ns（如果可能的话）的顺序中。唯一可能出现问题的地方是，由于方法的大小而无法内联一个方法（并且声明final会将其缩小几个字节）。

还有两个final需要解决的问题。首先是方法final（从JIT角度来看）时，这种方法是单态的 -并且它们是上最受欢迎的方法JVM。

然后是final实例变量（必须在每个构造函数中设置）；这些非常重要，因为它们将保证正确发布的参考文献（在此处有一点涉及，也由精确指定）JLS。

您实际上是在问两种（至少）不同的情况：

1. final 用于局部变量
2. final 用于方法/类

乔恩·斯凯特（Jon Skeet）已回答2）。大约1）：

我认为这没有什么不同；对于局部变量，编译器可以推断出该变量是否为最终变量（只需通过检查其是否分配了多次即可）。因此，如果编译器想要优化仅分配一次的变量，则无论是否实际声明变量，它都可以这样做final。

final 可能对受保护/公共类字段有所不同；对于编译器来说，很难发现该字段是否被设置了一次以上，因为它可能来自不同的类（甚至可能没有被加载）。但是即使那样，JVM仍可以使用Jon所描述的技术（乐观地进行优化，如果加载了确实改变了字段的类，则进行还原）。

总而言之，我认为没有任何理由可以帮助提高性能。因此，这种微观优化不太可能有所帮助。您可以尝试对其进行基准测试以确保确定，但是我怀疑这会有所作为。

编辑：

实际上，根据TimoWestkämper的回答，在某些情况下final 可以提高类字段的性能。我站得住了。

注意：不是Java专家

如果我没有记错我的Java，那么使用final关键字将几乎没有提高性能的方法。我一直都知道它存在于“好的代码”中-设计和可读性。

我不是专家，但是我想您应该final在类或方法中添加关键字（如果不会被覆盖），并且不要理会变量。如果有任何方法可以优化此类事情，编译器将为您完成。

实际上，在测试一些与OpenGL相关的代码时，我发现在私有字段上使用final修饰符会降低性能。这是我测试的课程的开始：

public class ShaderInput {

    private /* final */ float[] input;
    private /* final */ int[] strides;


    public ShaderInput()
    {
        this.input = new float[10];
        this.strides = new int[] { 0, 4, 8 };
    }


    public ShaderInput x(int stride, float val)
    {
        input[strides[stride] + 0] = val;
        return this;
    }

    // more stuff ...

这是我用来测试各种替代方法的性能的方法，其中包括ShaderInput类：

public static void test4()
{
    int arraySize = 10;
    float[] fb = new float[arraySize];
    for (int i = 0; i < arraySize; i++) {
        fb[i] = random.nextFloat();
    }
    int times = 1000000000;
    for (int i = 0; i < 10; ++i) {
        floatVectorTest(times, fb);
        arrayCopyTest(times, fb);
        shaderInputTest(times, fb);
        directFloatArrayTest(times, fb);
        System.out.println();
        System.gc();
    }
}

在第3次迭代后，随着VM的预热，我始终获得这些数字而没有最后一个关键词：

Simple array copy took   : 02.64
System.arrayCopy took    : 03.20
ShaderInput took         : 00.77
Unsafe float array took  : 05.47

使用 final关键字：

Simple array copy took   : 02.66
System.arrayCopy took    : 03.20
ShaderInput took         : 02.59
Unsafe float array took  : 06.24

注意ShaderInput测试的数字。

我是否公开字段还是私有字段都没有关系。

顺便说一句，还有更多令人困惑的事情。即使使用final关键字，ShaderInput类也胜过所有其他变体。这很了不起，因为它基本上是一个包装float数组的类，而其他测试则直接操作该数组。必须弄清楚这一点。可能与ShaderInput的流畅接口有关。

而且，对于小型数组，System.arrayCopy实际上显然比在for循环中将元素从一个数组复制到另一个数组要慢一些。并且使用sun.misc.Unsafe（以及直接的java.nio.FloatBuffer，在此未显示）执行abysmally。

最终（至少对于成员变量和参数而言）对人而言要多于对机器而言。

最好尽可能使变量最终化。我希望Java在默认情况下将“变量”定为final，并使用“ Mutable”关键字来允许更改。不可变的类会导致更好的线程代码，只要浏览每个成员前面都带有“ final”的类，就会很快显示出它是不可变的。

另一种情况-我一直在转换很多代码以使用@ NonNull / @ Nullable注释（您可以说方法参数不能为null，然后IDE会在您传递未标记@的变量时向您发出警告@ NonNull-整个事情蔓延到一个荒谬的程度。当成员变量或参数被标记为final时，证明成员变量或参数不能为null会容易得多，因为您知道它不会在其他任何地方重新分配。

我的建议是养成默认情况下为成员和参数应用final的习惯，它只是几个字符，但如果没有其他问题，将带您朝着改进编码风格的方向发展。

方法或类的final是另一个概念，因为它不允许非常有效的重用形式，并且并没有真正告诉读者很多信息。最好的用法可能是他们使String和其他内部类型最终化的方式，因此您可以在任何地方都依赖一致的行为-这样可以避免很多错误（尽管有时我喜欢扩展字符串....哦，可能性）

用final声明的成员将在整个程序中可用，因为与非final成员不同，如果未在程序中使用这些成员，则Garbage Collector仍将不小心使用它们，因此由于内存管理不当而可能导致性能问题。

final 关键字可以在Java中以五种方式使用。

1. 一堂课是最后的
2. 参考变量是最终的
3. 局部变量是最终的
4. 方法是最终的

一个类是最终的：一个类是最终的，这意味着我们不能扩展，或者继承意味着不可能的继承。

同样-对象是最终对象：有时我们不修改对象的内部状态，因此在这种情况下我们可以指定对象为最终对象。对象最终意味着既不是变量也不是最终对象。

一旦将参考变量设置为最终变量，就无法将其重新分配给其他对象。但是可以更改对象的内容，只要它的字段不是最终的