在Java中使用final关键字能提高性能吗?

在Java中，我们看到很多地方可以使用final关键字，但它的使用并不常见。

例如:

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

在上面的例子中，str可以是final，但通常不使用。

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

在任何或所有这些情况下使用final关键字真的能提高性能吗?如果是，那该怎么做?请解释一下。如果final的正确使用确实关系到性能，那么Java程序员应该养成什么样的习惯才能最好地利用这个关键字呢?

当前回答

是的，它可以。下面是一个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属性转换为final属性，您已经告诉编译器，无论何时看到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。这证明了最终变量对性能有影响，至少在这个简单的情况下是这样。

2013-06-27 05:33:09

其他回答

通常不会。对于虚方法，HotSpot会跟踪该方法是否实际被重写，并且能够在假定某个方法没有被重写的情况下执行优化，例如内联——直到它加载一个重写该方法的类，这时它可以撤销(或部分撤销)那些优化。

(当然，这是假设你正在使用HotSpot -但它是迄今为止最常见的JVM，所以…)

在我看来，使用final应该基于清晰的设计和可读性，而不是出于性能考虑。如果您出于性能原因想要更改任何内容，那么应该在修改最清晰的代码之前执行适当的度量——这样您就可以决定以较差的可读性/设计换取额外的性能是否值得。(根据我的经验，这几乎不值得;YMMV)。

EDIT: As final fields have been mentioned, it's worth bringing up that they are often a good idea anyway, in terms of clear design. They also change the guaranteed behaviour in terms of cross-thread visibility: after a constructor has completed, any final fields are guaranteed to be visible in other threads immediately. This is probably the most common use of final in my experience, although as a supporter of Josh Bloch's "design for inheritance or prohibit it" rule of thumb, I should probably use final more often for classes...

2010-11-25 17:11:41

根据IBM的说法——它不用于类或方法。

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

2010-11-25 17:14:08

注意:不是java专家

如果我没有记错我的java，使用final关键字几乎没有办法提高性能。我一直知道它的存在是为了“好代码”——设计和可读性。

2010-11-25 17:16:50

你实际上在问两种(至少)不同的情况:

局部变量的Final 方法/类的Final

Jon Skeet已经回答了2)。关于1):

我不认为这有什么区别;对于局部变量，编译器可以推断该变量是否是final变量(只需检查它是否被多次赋值)。因此，如果编译器想要优化只赋值一次的变量，无论变量是否声明为final，它都可以这样做。

Final可能会对protected/public类字段产生影响;在那里，编译器很难发现字段是否被设置了不止一次，因为它可能发生在不同的类中(甚至可能没有被加载)。但即使这样，JVM也可以使用Jon描述的技术(乐观地优化，如果加载了更改字段的类，则恢复)。