面试题：final、finally、finalize的区别

背景知识

final/finally在工作中几乎无时无刻不再使用，因此即便是没有系统化的梳理这个问题，也能回答出一些内容。

但是finalize就接触得非常少，接下来我们对这几个关键字逐一进行分析。

finial 关键字

final关键字大家都不陌生，但是要达到深度理解，还是欠缺了一些。我们从三个方面去理解final关键字。

final关键字的基本用法
深度理解final关键字
final关键字的内存屏障语义

基本用法

final关键字，在Java中可以修饰类、方法、变量。

被final修饰的类，表示这个类不可被继承，final类中的成员变量可以根据需要设为final，并且final修饰的类中的所有成员方法都被隐式指定为final方法.

在使用final修饰类的时候，要注意谨慎选择，除非这个类真的在以后不会用来继承或者出于安全的考虑，尽量不要将类设计为final类。
```
public final class FinalTest {

    public final String test() {
        return "true";
    }

}
```
然后创建一个类继承该类，我们可以发现如下错误。

被final修饰的方法，表示该方法无法被重写.其中private方法会被隐式的指定为final方法。

class SuperClass {
    protected final String getName() {
        return "supper class";
    }

    @Override
    public String toString() {
        return getName();
    }
}

3. 被final修饰的成员变量是用得最多的地方。

对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；final修饰的变量能间接实现常量的功能，而常量是全局的、不可变的，因此我们同时使用static和final来修饰变量，就能达到定义常量的效果。
如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。

被final修饰的变量的初始化

在定义时初始化属性的值
```
class SuperClass {

    private final String name;

    protected final String getName() {
        return "supper class";
    }

    @Override
    public String toString() {
        return getName();
    }
}
```
上述代码会出现错误，由于我们没有对数据进行初始化。

对name字段进行赋值即可。
在构造方法中赋值

除了直接赋值，我们也可以在构造方法中对属性赋值。
```
class SuperClass {

    private final String name;

    public SuperClass(String name) {
        this.name = name;
    }

    protected final String getName() {
        return "supper class";
    }

    @Override
    public String toString() {
        return getName();
    }
}
```
能够在构造方法中赋值的原因是：对于一个普通成员属性赋值时，必须要先通过构造方法实例化该对象。因此作为该属性唯一的访问入口，JVM允许在构造方法中给final修饰的属性赋值。这个过程并没有违反final的原则。当然如果被修饰final关键字的属性已经初始化了值，是无法再使用构造方法重新赋值的。

反射破坏final规则

基于上述final关键字的基本使用描述，可以知道final修饰的属性是不可变的。

但是，通过反射机制，可以破坏final的规则，代码如下：

class SuperClass {

    private final String name = "name";

    public static void main(String[] args) throws Exception {
        SuperClass superClass = new SuperClass();
        System.out.println(superClass.name);

        Field field = superClass.getClass().getDeclaredField("name");
        field.setAccessible(true);
        field.set(superClass, "chen");
        System.out.println(field.get(superClass));
    }
}

结果如下：

name
chen

知识点扩展

上述代码理论上来说应该是下面这种写法，因为通过反射修改tcc实例对象中的name属性后，应该通过实例对象直接打印出name的结果。

public static void main(String[] args) throws Exception {
        SuperClass superClass = new SuperClass();
        System.out.println(superClass.name);

        Field field = superClass.getClass().getDeclaredField("name");
        field.setAccessible(true);
        field.set(superClass, "chen");
        //System.out.println(field.get(superClass));
        System.out.println(superClass.name);
}

但是实际输出结果后，发现superClass.name打印的结果没有变化？

原因是：JVM在编译时期做的深度优化机制, 就把final类型的String进行了优化, 在编译时期就会把String处理成常量，导致打印结果不会发生变化。

为了避免这种深度优化带来的影响，我们还可以把上述代码修改成下面这种形式

	//处理jvm带来的深度优化
    private final String name=(null == null ? "name" : "");


    public static void main(String[] args) throws Exception {
        SuperClass superClass = new SuperClass();
        System.out.println(superClass.name);

        Field field = superClass.getClass().getDeclaredField("name");
        field.setAccessible(true);
        field.set(superClass, "chen");
        //System.out.println(field.get(superClass));
        System.out.println(superClass.name);
    }

打印结果如下:

name
chen

反射无法修改被final和static同时修饰的变量

把上面的代码修改如下。

private static final String name=(null == null ? "name" : "");

会出现如下报错：

Exception in thread "main" java.lang.IllegalAccessException: Can not set static final java.lang.String field com.example.javastudy.interview.SuperClass.name to java.lang.String
	at sun.reflect.UnsafeFieldAccessorImpl.throwFinalFieldIllegalAccessException(UnsafeFieldAccessorImpl.java:76)
	at sun.reflect.UnsafeFieldAccessorImpl.throwFinalFieldIllegalAccessException(UnsafeFieldAccessorImpl.java:80)
	at sun.reflect.UnsafeQualifiedStaticObjectFieldAccessorImpl.set(UnsafeQualifiedStaticObjectFieldAccessorImpl.java:77)
	at java.lang.reflect.Field.set(Field.java:764)
	at com.example.javastudy.interview.SuperClass.main(SuperClass.java:26)

那么被final和static同时修饰的属性，能否被修改呢？答案是可以的！

修改代码如下：

//处理jvm带来的深度优化
private static final String name = (null == null ? "name" : "");


public static void main(String[] args) throws Exception {
    SuperClass superClass = new SuperClass();
    System.out.println(superClass.name);

    Field field = superClass.getClass().getDeclaredField("name");
    field.setAccessible(true);

    // 去除 final关键字 实现 对 static 及 final 属性修改
    Field modifiers = field.getClass().getDeclaredField("modifiers");
    modifiers.setAccessible(true);
    modifiers.setInt(field, field.getModifiers() & ~Modifier.FINAL);

    field.set(superClass, "chen");

    modifiers.setInt(field, field.getModifiers() & ~Modifier.FINAL);

    System.out.println(superClass.name);
}

具体思路是，把被修饰了final关键字的name属性，通过反射的方式去掉final关键字，接着通过反射修改name属性，修改成功后，再使用下面代码把final关键字加回来

		modifiers.setInt(field, field.getModifiers() & ~Modifier.FINAL);

        field.set(superClass, "chen");

        modifiers.setInt(field, field.getModifiers() & ~Modifier.FINAL);

为什么局部内部类和匿名内部类只能访问final变量

在了解这个问题之前，我们在之前的类中添加下面这段代码：

public void test(final int b) {
        final int a = 10;
        new Thread(){
            public void run() {
                System.out.println(a);
                System.out.println(b);
            };
        }.start();
    }

这段代码被编译后，会生成两个文件: SuperClass.class和 SuperClass$1.class（匿名内部类）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sWcvKSNr-1636088510015)(final、finally、finalize的区别.assets/image-20211105112752171.png)]

通过反编译来看一下SuperClass$1.class这个类

class SuperClass$1 extends Thread {
    SuperClass$1(SuperClass this$0, int var2, int var3) {
        this.this$0 = this$0;
        this.val$a = var2;
        this.val$b = var3;
    }

    public void run() {
        System.out.println(this.val$a);
        System.out.println(this.val$b);
    }
}

我们看到匿名内部类FinalExample$1的构造器含有三个参数，一个是指向外部类对象的引用，另外两个是int型变量，很显然，这里是将变量test方法中的形参b，以及常量a以参数的形式传进来，对匿名内部类中的拷贝（变量a和b的拷贝）进行赋值初始化。

也就是说，在run方法中访问的变量a和b，是局部变量a和b的一个副本，为什么这么设计？

在test方法中，有可能test方法执行结束且a和b的声明周期也结束了，但是Thread这个匿名内部类可能还未执行完，那么在Thread中的run方法中继续使用局部变量a和b就会有问题。但是又要实现这样的效果，怎么办呢？所以Java采用了复制的手段来解决这个问题。

但是这样一来，还是存在一个问题，就是test方法中的成员变量与匿名内部类Thread中的成员变量的副本出现数据不一致怎么办？

这样就达不到原本的意图和要求。为了解决这个问题，java编译器就限定必须将变量a和b限制为final变量，不允许对变量a和b进行更改（对于引用类型的变量，是不允许指向新的对象），这样数据不一致性的问题就得以解决了。

另外，如果我们这么写也是允许的，jvm会隐式给a和b增加final关键字。

public void test(int b) {
  int a = 10;
  new Thread(){
    public void run() {
      System.out.println(a);
      System.out.println(b);
    };
  }.start();
}

final防止指令重排

final关键字，还能防止指令重排序带来的可见性问题；

对于final变量，编译器和处理器都要遵守两个重排序规则：

构造函数内，对一个 final 变量的写入，与随后把这个被构造对象的引用赋值给一个变量，这两个操作之间不可重排序。
首次读一个包含 final 变量的对象，与随后首次读这个 final 变量，这两个操作之间不可以重排序。

实际上这两个规则也正是针对 final 变量的写与读。

写的重排序规则可以保证，在对象引用对任意线程可见之前，对象的 final 变量已经正确初始化了，而普通变量则不具有这个保障；
读的重排序规则可以保证，在读一个对象的 final 变量之前，一定会先读这个对象的引用。如果读取到的引用不为空，根据上面的写规则，说明对象的 final 变量一定以及初始化完毕，从而可以读到正确的变量值。

如果 final 变量的类型是引用型，那么构造函数内，对一个 final 引用的对象的成员域的写入，与随后在构造函数外把这个被构造对象的引用赋值给一个引用变量，这两个操作之间不能重排序。实际上这也是为了保证 final 变量在对其他线程可见之前，能够正确的初始化完成。

final 关键字的好处

final关键字提高了性能，JVM和Java应用都会缓存final变量（实际就是常量池）
final变量可以安全的在多线程环境下进行共享，而不需要额外的同步开销

问题解答

面试题：用过final关键字吗？它有什么作用

回答：final关键字表示不可变，它可以修饰在类、方法、成员变量中。

如果修饰在类上，则表示该类不允许被继承
修饰在方法上，表示该方法无法被重写
修饰在变量上，表示该变量无法被修改，而且JVM会隐性定义为一个常量。

另外，final修饰的关键字，还可以避免因为指令重排序带来的可见性问题，原因是，final遵循两个重排序规则

构造函数内，对一个 final 变量的写入，与随后把这个被构造对象的引用赋值给一个变量，这两个操作之间不可重排序。
首次读一个包含 final 变量的对象，与随后首次读这个 final 变量，这两个操作之间不可以重排序。

finally关键字

finally关键字用在try语句块后面，它的常用形式是：

try{

}catch(){

}finally{

}

finally语句块中的代码，无论try或者catch代码块中是否有异常，finally语句块中的代码一定会被执行，所以它一般用于清理工作、关闭链接等类型的语句。

它的特点：

finally语句一定会伴随try语句出现。
try语句不能单独使用，必须配合catch语句或finally语句。
try语句可以单独与catch语句一起使用，也可以单独与finally语句一起使用，也可以三者一起使用。

finally 实战思考

为了加深大家对于finally关键字的理解，我们来看下面这段代码。

思考一下，下面这段代码，打印的结果分别是多少？

public class FinallyExample {

    public static void main(String arg[]) {
        System.out.println(getNumber(0));
        System.out.println(getNumber(1));
        System.out.println(getNumber(2));
        System.out.println(getNumber(4));
    }

    public static int getNumber(int num) {
        try {
            int result = 2 / num;
            return result;
        } catch (Exception exception) {
            return 0;
        } finally {
            if (num == 0) {
                return -1;
            }
            if (num == 1) {
                return 1;
            }
        }
    }

}

正确答案分别是：

-1：传入num=0，此时会报错java.lang.ArithmeticException: / by zero。因此进入到catch捕获该异常。由于finally语句块一定会被执行，因此进入到finally语句块，返回-1。
1：传入num=1，此时程序运行正常，由于finally语句块一定会被执行，因此进入到finally代码块，得到结果1。
1：传入num=2，此时程序运行正常，result=1，由于finally语句块一定会被执行，因此进入到finally代码块，但是finally语句块并没有触发对结果的修改，所以返回结果为1。
0：传入num=4，此时程序运行正常，result=0(因为2/4=0.5，转换为int后得到0)，由于finally语句块一定会被执行，因此进入到finally代码块，但是finally语句块并没有触发对结果的修改，所以返回结果为0。

什么情况下`finally`不会执行

finally代码块，是否有存在不会被执行的情况呢？

System.exit()

来看下面这段代码：

public class FinallyExample {

    public static void main(String arg[]){
        System.out.println(getNumber(0));
    }
    public static int getNumber(int num){
        try{
            int result=2/num;
            return result;
        }catch(Exception exception){
            System.out.println("触发异常执行");
            System.exit(0);
            return 0;
        }finally{
            System.out.println("执行finally语句块");
        }
    }
}

在catch语句块中，增加了System.exit(0)代码，执行结果如下

触发异常执行

可以发现，在这种情况下，并没有执行finally语句块。

该方法用来结束当前正在运行的Java JVM。如果 status 是非零参数，那么表示是非正常退出。

System.exit(0) ：将整个虚拟机里的内容都关掉，内存都释放掉！正常退出程序。

System.exit(1) ：非正常退出程序

System.exit(-1) ：非正常退出程序

由于当前JVM已经结束了，因此程序代码自然不能继续执行。

守护线程被中断

先来看下面这段代码：

public class FinallyExample {

    public static void main(String[] args) {
        Thread t = new Thread(new Task());
        t.setDaemon(true); //置为守护线程
        t.start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException("the "+Thread.currentThread().getName()+" has been interrupted",e);
        }
    }

}

class Task implements Runnable {
    @Override
    public void run() {
        System.out.println("执行 run()方法");
        try {
            System.out.println("执行 try 语句块");
            TimeUnit.SECONDS.sleep(5); //阻塞5s
        } catch (InterruptedException e) {
            System.out.println("执行 catch 语句块");
            throw new RuntimeException("the " + Thread.currentThread().getName() + " has been interrupted", e);
        } finally {
            System.out.println("执行 finally 语句块");
        }
    }
}

运行结果如下:

执行 run()方法
执行 try 语句块

从结果发现，finally语句块中的代码并没有被执行？为什么呢？

守护线程的特性是：只要JVM中没有任何非守护线程在运行，那么虚拟机会kill掉所有守护线程从而终止程序。换句话说，就是守护线程是否正在运行，都不影响JVM的终止。

在虚拟机中，垃圾回收线程以及main线程都是守护线程。

在上述运行的程序中，执行逻辑描述如下：

线程t是守护线程，它开启一个任务Task执行，该线程t在main方法中执行，并且在睡眠1s之后，main方法执行结束
Task是一个守护线程的执行任务，该任务睡眠5s。

基于守护线程的特性，main和task都是守护线程，因此当main线程执行结束后，并不会因为Task这个线程还未执行结束而阻塞。而是在等待1s后，结束该进程。

这就使得Task这个线程的代码还未执行完成，但是JVM进程已结束，所以finally语句块没有被执行。

finally执行顺序

基于上述内容的理解，是不是自认为对finally关键字掌握很好了？那我们在来看看下面这个问题。

重新创建类，方便查看字节码。

这段代码的执行结果是多少呢？

public class FinallyExample2 {

  public int add() {
    int x = 1;
    try {
      return ++x;
    } catch (Exception e) {
      System.out.println("执行catch语句块");
      ++x;
    } finally {
      System.out.println("执行finally语句块");
      ++x;
    }
    return x;
  }
    
  public static void main(String[] args) {
    FinallyExample2 t = new FinallyExample2();
    int y = t.add();
    System.out.println(y);
  }
    
}

上述程序运行的结果是：2

这个结果应该有点意外，因为按照finally的语义，首先执行try代码块，++x后得到的结果应该是2，接着再执行finally语句块，应该是在2的基础上再+1，得到结果是3，那为什么是2？

这边设计到字节码的相关问题，就不详细阐述，我们可以大致理解为：如果 try 语句里有 return，那么代码的行为如下：

如果有返回值，就把返回值保存到局部变量中
执行 jsr 指令跳到 finally 语句里执行
执行完 finally 语句后，返回之前保存在局部变量表里的值

finalize方法

finalize 方法定义在 Object 类中，其方法定义如下：

protected void finalize() throws Throwable {
}

当一个类在被回收期间，这个方法就可能会被调用到。

它有使用规则是：

当对象不再被任何对象引用时，GC会调用该对象的finalize()方法
finalize()是Object的方法，子类可以覆盖这个方法来做一些系统资源的释放或者数据的清理
可以在finalize()让这个对象再次被引用，避免被GC回收；但是最常用的目的还是做cleanup
Java不保证这个finalize()一定被执行；但是保证调用finalize的线程没有持有任何user-visible同步锁。
在finalize里面抛出的异常会被忽略，同时方法终止。
当finalize被调用之后，JVM会再一次检测这个对象是否能被存活的线程访问得到，如果不是，则清除该对象。也就是finalize只能被调用一次；也就是说，覆盖了finalize方法的对象需要经过两个GC周期才能被清除。

问题回答

面试题：final、finally、finalize的区别

回答：

final用来修饰类、方法、属性，被final修饰的类，表示该类无法被继承，被final修饰的属性，表示该属性无法被修改，被final修饰的方法，表示该方法无法被重写
finally，它和try语句块组成一个完整的语法，表示一定会被执行的代码块，当然也有方式可以破坏它的执行特性
1. 通过System.exit
2. 守护线程的终止
finalize方法，是一个类被回收期间可能会被调用的方法。