java并发(5)深入理解final关键字

简介

final是java的关键字，可以声明成员变量、方法、类以及本地变量,它所表示的是这部分是无法修改的。不想被改变的原因有两个：出于代码效率和安全的结构设计。

final作用于方法

final 修饰方法,则表明该方法不能被重写(override),所以对于 final 方法使用的第一个原因是针对结构设计的,进行方法锁定，以防止任何子类来对它的修改.

final 方法, 在某些情况下可以对执行效率产生帮助.对于被修饰为final的方法,在编译器期的时候,有可能会进行内联(inline)优化.

类中的 private 方法,编译器会自动帮它加上 final.

内联调用

是编译器为程序做的一种优化操作.虚拟机不再执行正常的方法调用（参数压栈，跳转到方法处执行，再调回，处理栈参数，处理返回值），而是直接将方法展开，以方法体中的实际代码替代原来的方法调用。这样减少了方法调用的开销。

内联需要关注的特点:

如果方法被多次调用,或者内联的方法将会被多次拷贝,会相应的增加内存占用. 这是一种空间置换时间的一个策略.
如果方法体代码量过大,拷贝的次数过多,那么将反而达不到优化的目的.
对于final方法是否进行内联,由编译器决定,并不是所有的final方法都会被内联.
编译器进行内联优化,并不只针对final方法, 如单行实现的方法也可能被内联.

总结 :

在方法中, 不用刻意的使用final,反而应该出于安全考量,多用私有方法, 公开或包方法则判断是否允许被修改,进而选择性的加上 final.

final作用于类

如果某个类用 final 修改，表明该类是最终类，它不希望也不允许其他来继承它。在程序设计中处于安全或者其他原因，我们不允许该类存在任何变化，也不希望它有子类，这个时候就可以使用 final 来修饰该类了.

final修饰的类,其成员方法也会自动加上final修饰,而成员变量不受影响.

final作用于变量

final作用于成员变量

修饰基本数据类型变量和字面量

final修饰基本数据类型和字面量时, 被修饰的变量会被当成是常量处理, 加入常量池中.

// 源码
public class Test {
    final int a = 1;
    final String b = "2";
    
    void test() {
        System.out.println(a);
    }
}

// 反汇编
{
  final java.lang.String a;
    descriptor: Ljava/lang/String;
    flags: (0x0010) ACC_FINAL

  final java.lang.String b;
    descriptor: Ljava/lang/String;
    flags: (0x0010) ACC_FINAL
    ConstantValue: String 2
    
// 反编译
void test() {
    System.out.println(1);
}

对于常量, JVM会在编译期直接带入变量中,提高性能.

修饰对象

修饰对象,则对象只能在构造函数中初始化, 并且初始化后, 对象的引用不可变.

final作用于局部变量

网上经常看到, 局部变量添加 final修饰能够提高效率. 这句话严格意义上是错误的.

在能够通过编译的前提下，无论局部变量声明时带不带final关键字修饰，对其访问的效率都一样。将静态变量和成员变量局部化与“final”没关系，只与“局部变量”有关——重复访问一个局部变量比重复访问一个成员或静态变量快；即便将其final修饰符去掉，效果也一样。

// 源码的方法    
    void localFinalMethod() {
        final int    a = getA();
        final String b = getB();
    }

    void localVarMethod() {
        int    a = getA();
        String b = getB();
    }

// 反汇编后
  void localFinalMethod();
    Code:
       0: aload_0
       1: invokespecial #2                  // Method getA:()I
       4: istore_1
       5: aload_0
       6: invokespecial #3                  // Method getB:()Ljava/lang/String;
       9: astore_2
      10: return

  void localVarMethod();
    Code:
       0: aload_0
       1: invokespecial #2                  // Method getA:()I
       4: istore_1
       5: aload_0
       6: invokespecial #3                  // Method getB:()Ljava/lang/String;
       9: astore_2
      10: return

发现反汇编后的代码没有什么区别,字节码里没有任何东西能体现出局部变量的final与否。既然带不带final的局部变量在编译到Class文件后都一样了，其访问效率必然一样高，JVM不可能有办法知道什么局部变量原本是用final修饰来声明的。

而只有当局部变量是字面量时,使用final, 将会把局部变量当做常量来处理, 提高效率.

// 源码方法
    void localFinalMethod() {
        final int a = 3;
        final int b = 4;
        int       c = a + b;
    }

    void localVarMethod() {
        int a = 3;
        int b = 4;
        int c = a + b;
    }

    void localVarMethod5() {
        final int a = 3;
        final int b = 4;
        int c = 7;
    }

// 反汇编
  void localFinalMethod();
    Code:
       0: iconst_3          // 常量3 入栈
       1: istore_1          // 赋值给第一个局部变量a
       2: iconst_4          // 常量4 入栈
       3: istore_2          // 赋值给第二个局部变量b
       
       4: bipush        7   // 加载常量7
       6: istore_3          // 赋值给第三个局部变量c
       7: return

  void localVarMethod();
    Code:
       0: iconst_3          // 和上面一样
       1: istore_1
       2: iconst_4
       3: istore_2
       
       4: iload_1           // 变量a 入栈
       5: iload_2           // 变量b 入栈
       6: iadd              // a,b 加法运算
       7: istore_3          // 结果赋值给c
       8: return

  void localVarMethod5();
    Code:
       0: iconst_3          // 和第一个方法一模一样
       1: istore_1
       2: iconst_4
       3: istore_2
       
       4: bipush        7
       6: istore_3
       7: return

从上面代码上可以看出, final 修饰局部字面量, 会直接变为计算后的值, 进而提升了效率.

总结:

重复访问一个局部变量比重复访问一个成员或静态变量快.
局部变量在非修饰字面量情况下,对效率没有帮助,只是程序员的一种自我约束,表明不能去修改改局部变量.
局部变量中,final修饰字面量, 对效率有一定的帮助.

final作用于匿名内部类

局部变量或者方法参数传递到匿名内部类时, 需要将变量声明为final类型,否则编译器将会报错.(Java8 不需要手动添加, 但是编译器会帮你添加.)

为什么会这样做呢? 我们来看下匿名内部类在 JVM中的实现.

    // 源码
    void anonymousClass() {
        final int a = 1;
        new Runnable() {
            @Override
            public void run() {
                System.out.println(a);
            }
        };
    }
    
// 反汇编的 匿名内部类Runnable
class Test$1 implements java.lang.Runnable {
  final int val$a;                          // 持有外部局部变量的副本或引用

  final Test this$0;                        // 持有外部类的引用

  Test$1(Test, int);
    Code:
       0: aload_0
       1: aload_1
       2: putfield      #1                  // Field this$0:LTest;
       5: aload_0
       6: iload_2
       7: putfield      #2                  // Field val$a:I
      10: aload_0
      11: invokespecial #3                  // Method java/lang/Object."<init>":()V
      14: return

  public void run();
    Code:
       0: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: aload_0
       4: getfield      #2                  // Field val$a:I
       7: invokevirtual #5                  // Method java/io/PrintStream.println:(I)V
      10: return
}

可以看出,匿名内部类持有外部对象的引用, 这也是为什么匿名内部类可以直接调用外部对象的方法和成员变量的原因.

匿名内部类还持有, 匿名内部类内部使用的局部变量的副本或引用,把它单程自己的成员变量. 而这个也是为什么局部变量给匿名内部类使用的时候要添加 final的原因.

原因就是为了避免匿名内部类对成员变量的修改对外部的局部变量不可见, 导致内部虽然已修改, 但是外部感知不到, 造成数据不一致的问题.

final 对用于成员变量(Filed)在并发中作用

final的内存语义 : 只要对象是正确构造的 (被构造对象的引用在构造函数中没有“逸出”) ，那么不需要使用同步 （指lock和volatile的使用） 就可以保证任意线程都能看到这个final域在构造函数中被初始化之后的值。

final域的重排序规则

1. 在构造函数内对一个final域的写入，与随后把这个被构造对象的引用赋值给一个引用变量，这两个操作之间不能重排序。

初次读取一个包含final域的对象的引用，与随后初次读这个final域，这两个操作之间不能重排序。

编译器会在final域的写之后，构造函数return之前，插入一个StoreStore屏障。

编译器会在读final域操作的前面插入一个LoadLoad屏障。

public class FinalExample {
    int i;                          // 普通变量
    final int j;                    // final变量
    static FinalExample obj;
    public FinalExample () {        // 构造函数
        i = 1;                      // 写普通域
        j = 2;                      // 写final域
    }
    public static void writer () {  // 写线程A执行
        obj = new FinalExample ();
    }
    public static void reader () {  // 读线程B执行
        FinalExample object = obj;  // 读对象引用
        int a = object.i;           // 读普通域
        int b = object.j;           // 读final域
    }
}

可能出现的异常情况: 普通变量的写被重排序到构造函数之外.

final域的重排序规则.png

普通域写被重排序, 导致线程B,读取到的i变量是未初始化的值.

构造函数逸出

构造函数"逸出" : 在构造函数内部，这个被构造对象的引用为其他线程所见.如构造函数中将this赋值给成员变量.

public class FinalReference {
    final  int            i;
    static FinalReference obj;

    public FinalReference() {
        i = 1;                  // 1. 写final域
        obj = this;             // 2. this引用在此"逸出"
    }

    public static void writer() {
        new FinalReference();
    }

    public static void reader() {
        if (obj != null) {      // 3.
            int temp = obj.i;   // 4.
        }
    }
}

构造函数"逸出",将不能保证final语义.
在构造函数返回前，被构造对象的引用不能为其他线程所见,因为此时的final域可能还没有被初始化。

final 在构造器外部赋值和在内部赋值的差异

// 源码
public class FinalExample {
    final int a = 1;
    final int b;
    int c;

    public FinalExample() {
        this.b = 2;
        this.c = 3;
    }

    void test() {
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    }
}
// 反汇编
{
  final int a;
    descriptor: I
    flags: (0x0010) ACC_FINAL
    ConstantValue: int 1

  final int b;
    descriptor: I
    flags: (0x0010) ACC_FINAL

  int c;
    descriptor: I
    flags: (0x0000)

  public FinalExample();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: aload_0
         5: iconst_1
         6: putfield      #2                  // Field a:I
         9: aload_0
        10: iconst_2
        11: putfield      #3                  // Field b:I
        14: aload_0
        15: iconst_3
        16: putfield      #4                  // Field c:I
        19: return

  void test();
    descriptor: ()V
    flags: (0x0000)
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: iconst_1
         4: invokevirtual #7                  // Method java/io/PrintStream.println:(I)V
         7: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
        10: aload_0
        11: getfield      #3                  // Field b:I
        14: invokevirtual #7                  // Method java/io/PrintStream.println:(I)V
        17: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
        20: aload_0
        21: getfield      #4                  // Field c:I
        24: invokevirtual #7                  // Method java/io/PrintStream.println:(I)V
        27: return
}

从反汇编可以看到一个奇特的现象.

在构造器外部赋值的final修饰的字面量会被加入到常量池中,当成常量, 并且后续调用时,在编译期会直接被替换为常量值.

而在构造器赋值的final修饰的字面量不会被加入到常量池, 并且后续调用也不会被替换成常量.

总结

final 在java中有很重要的作用, 主要体现在执行效率和代码安全上, 附带线程安全的作用. 我们要在理解final原理的情况下正确的使用它, 不应该随意使用造成滥用的情况.