final 详解

final 这个平时经常在工具类中用到的关键字，通常知道的是它可以用来修饰类、方法、变量，修饰后表示「不可变」。但除此之外，final 经常在多线程并发场景下被提及，java 编程语言规范中也在 17 章 Thread and Locks 中提及到了 final，所以 final 在多线程的场景下有些什么特点值得深思

基础使用

快速过下 final 修饰类、方法、变量的特点

修饰类

当某个类被 final 时，这个类无法被继承，即这个类是不能有子类的

final 类中的所有方法都隐式为 final，因为无法覆盖他们，所以在 final 类中给任何方法添加 final 关键字是没有任何意义的

不过虽然无法被继承，但可以通过组合的方式来拓展这个类

class MyString {
    private String innnerString;
    
    // 对旧方法的支持
    public int length() {
        return innerString.length();
    }
    
    // 添加新方法
    public void m1() {
        ...
    }
}

修饰方法

public static void main(String[] args) {
        C2 c2 = new C2();
        c2.m1();
        c2.m2();
        C1 c1 = c2;
        c1.m1();
        c1.m2();
    }

private static class C1 {
    private void m1() {
        System.out.println("c1 m1");
    }
    public void m2() {
        System.out.println("c1 m2");
    }
}

private static class C2 extends C1 {
    private void m1() {
        System.out.println("c2 m1");
    }
    public void m2() {
        System.out.println("c2 m2");
    }
}

Out：

c2 m1
c2 m2
c1 m1
c2 m2

两个特点：

• private 修饰的方法是隐式的 final
• final 方法不能被覆盖，但是能被重载

修饰变量

public class Test {
    //编译期常量
    final int i = 1;
    final static int J = 1;
    final int[] a = {1,2,3,4};
    //非编译期常量
    Random r = new Random();
    // k的值由随机数对象决定，只是k在初始化后无法被更改
    final int k = r.nextInt();
}

• static final 修饰的变量声明即刻赋值
• final 变量可以在构造函数内赋值

final 域重排序规则

编译器、处理器和 JIT 编译器的指令重排序优化可能会导致多线程下的有序性问题，而由于 final 的不可更改性，因此编译器会针对 final 域的指令重排遵循新的规则

final 基本类型

class FinalTest2 {

    final int x;
    int y;
    static FinalTest2 f;

    public FinalTest2() {
        x = 3;
        y = 4;
    }

    static void writer() {
        f = new FinalTest2();
    }

    static void reader() {
        if (f == null) {
            System.out.println("f is null!");
        } else {
            System.out.println("f.y: " + f.y);
            System.out.println("f.x: " + f.x);
        }
    }

    public static void main(String[] args) {
        new Thread(FinalTest2::writer).start();
        new Thread(FinalTest2::reader).start();
    }
}

由于 x，y 之间没有依赖性，普通变量 y 可能会被重排序到构造函数之外，这样 reader 线程读到的 y 可能是一个还未完成赋值的默认值 0

final 引用类型

class FinalTest3 {

    final int[] arrays;
    FinalTest3 f;

    public FinalTest3() {
        arrays = new int[1];
        arrays[0] = 1;
    }

    void write() {
        f = new FinalTest3();
    }

    void read() {
        if (f == null) {
            System.out.println("f is null");
        } else {
            System.out.println("f's arrays is: " + f.arrays[0]);
        }
    }

    public static void main(String[] args) {
        FinalTest3 test3 = new FinalTest3();
        new Thread(test3::write).start();
        new Thread(test3::read).start();
    }
}

f.arrays[0] 输出的结果总是 0，说明 array[0] = 1 无法从构造函数中逃逸出来

重排序原理

由于 final 的不可变特性，如果 final 变量在构造函数中初始化，使得 JVM 会在构造函数返回前加入 StoreStore 屏障，其他线程在读取 final 变量前会加入 LoadLoad 屏障，屏障保证了 final 变量的有序性与可见性，即保证每个线程看到的值都会是相同的

引用类型会额外保证构造函数内对 final 对象写入的有序性与可见性

this 溢出

final 可以保证在使用一个 final 对象的引用时，该对象已被构造函数初始化完成过

但需要 避免在构造过程中泄露 this，即不要在构造函数中引用 this，这可能导致其他线程访问到初始化部分的对象

public class FinalReferenceEscapeDemo {
    private final int a;
    private FinalReferenceEscapeDemo referenceDemo;

    public FinalReferenceEscapeDemo() {
        a = 1;  //1
        referenceDemo = this; //2
    }

    public void writer() {
        new FinalReferenceEscapeDemo();
    }

    public void reader() {
        if (referenceDemo != null) {  //3
            int temp = referenceDemo.a; //4
        }
    }
}

假设一个线程 A 执行 writer 方法另一个线程 B 执行 reader 方法。因为构造函数中操作 1 和 2 之间没有数据依赖性，1 和 2 可以重排序，先执行了 2，这个时候引用对象 referenceDemo 是个没有完全初始化的对象，而当线程 B 去读取该对象时就会出错。尽管依然满足了 final 域写重排序规则：在引用对象对所有线程可见时，其 final 域已经完全初始化成功。但是，引用对象 this 逸出，该代码依然存在线程安全的问题

String 线程安全吗

String 是线程安全的

既然如此

static String s = "1";

public static void main(String[] args) {
    for (int i = 0; i < 10; i++) {
        new Thread(() -> {
            s += "1";
        }).start();
    }
    System.out.println(s);
}

String 依旧是线程安全的，只不过这里并没有用 String，而是创建了一堆 String