final域的内存语义

最近看了《java并发编程的艺术》，3.6节讲解了final域的内存语义。简单总结下。

1.final域的的重排序规则

对应final域，编译器和处理器需要遵守两个重排序规则

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

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

实例代码：

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域
    }
}

假设一个线程A执行writer()方法，随后另一个线程执行B执行reader()方法，通过两个线程的交互说明上面的两个规则。

2.写final域的重排序规则

写final域的重排序规则禁止把final域的写重排序到构造函数之外。具体包含两个方面：

①JMM禁止编译器把final域的写重排序到构造函数之外。

②编译器会在final域的写之后，构造函数return之前，插入一个StoreStore屏障。该屏障禁止处理器把final域的写重排序到构造函数之外。

看write()方法，只包含一行代码 finalExample = new FinalExample()。这一行代码包含两个步骤：

①构造一个FinalExample类型的对象。

②把这个对象的引用赋值给引用变量obj。

假设线程B读对象引用（FinalExample object = obj）与读对象的成员域之间（int a = object.i;int b = object.j）没有重排序，下面的图是一种可能的执行时序：

从上面可能的时序图中我们可以看到，写普通域被编译器重排序到了构造函数之外，读线程B错误的读取了普通变量i初始化之前的值。写final域的操作，被写final域的重排序规则“限制”到了构造函数之内，读线程B正确读取了final变量初始化之后的值。

即读线程B读取对象引用obj时，obj很可能没有构造完成，对普通域i的写操作被重排序到构造函数之外，初始值1还没有被写入到普通域i。

总结：写final域的重排序规则可以确保在对象引用为任意线程可见之前，对象的final域已经被正常的初始化了，而普通域不具有这样的保证。

3.读final域的重排序规则

读final域的重排序规则是，在一个线程中，初次读对象引用与初次读该对象包含的final域，JMM禁止处理器重排序这两个操作（仅仅针对处理器）。编译器会在读final域操作的前面插入一个LoadLoad屏障。

初次读对象的引用与初次读该对象包含的final域，这两个操作之间存在间接依赖关系。编译器遵守间接依赖关系，因此编译器不会重排序这两个操作。大多数处理器也会遵守间接依赖，但有个别处理器允许对存在间接依赖关系的操作做重排序（如alpha处理器），所以说这个读final域的重排序规则就是专门针对这种处理器。

reader()方法包含3个步骤：

①初次读引用变量obj

②初次读引用变量obj指向对象的普通域 i

③初次读引用变量obj指向对象的final域 j

我们假设写线程A没有发生任何重排序，同时程序在不遵守间接依赖的处理器上执行，则下图是一种可能的时序：

从上图可以看出，读对象的普通域的操作被处理器重排序到读对象引用之前。读普通域时，该域还没有被线程A写入，所以上面的是一个错误的读取操作。但是读final域的重排序规则把读对象final域的操作“限定”在读对象引用之后，该final域已经被A线程初始化了，是一个正确的读取操作。

小结：读final域的重排序规则可以确保在读一个对象的final域之前，一定会先读包含这个final域的对象的引用。

4.final域为引用类型

下面说一下final域是引用类型的情况

public class FinalReferenceExample {
    final int[] intArray;       // final 是引用类型
    static FinalReferenceExample obj;
    
    public FinalReferenceExample() {   // 构造函数
        intArray = new int[1];         // 1
        intArray[0] = 1;               // 2
    }
    
    public static void writerOne() {   // 写线程A执行
        obj = new FinalReferenceExample();// 3
    }
    
    public static void writeTwo() {     // 写线程B执行
        obj.intArray[0] = 2;            // 4
    }
    
    public static void reader() {       // 读线程C执行
        if (obj != null) {              // 5
            int temp1 = obj.intArray[0];// 6
        }
    }
}

本例final域为数组的引用类型，写final域的重排序规则对编译器和处理器增加了如下约束：

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

假设线程A执行writeOne()方法，执行完成后线程B执行writeTwo()方法，执行完成后线程C执行reader()方法，下图是一种坑你的时序：

在上图中，1是对final域的写入，2是对final域引用的对象的成员域的写入，3是把被构造的对象的引用赋值给某个引用变量。这里1和3，2和3都不能重排序。JMM可以保证读线程C至少能看到写线程A在构造函数中国对final引用对象的成员域的写入。即线程C至少能看到数组下标0的值为1。线程B对数组元素的写入，读线程C不一定能保证看到。要想保证读线程C看到线程B对数组元素的写入，写线程B和读线程C之间需要使用同步原语（lock或volatile）保证内存可见性。

5.为什么final引用不能从构造函数内“逸出”

通过上面的介绍，我们知道：写final域的重排序规则可以确保：在引用变量为任意线程课件之前，读引用变量的指向的对象的final域已经在构造函数中被正确初始化了。但是这里面，还需要另外一点的保证：在构造函数内部，不能让这个被构造对象的引用为其他线程所见，即对象引用不能再构造函数中“逸出”，关于“逸出”的可以看我另一篇文章逸出

public class FinalReferenceEscapeExample {
    final int i;
    static FinalReferenceEscapeExample obj;
    
    public FinalReferenceEscapeExample() {
        i = 1;                            // 1 写final域
        obj = this;                       // 2 this引用在此”逸出“
    }
    
    public static void writer() {
        new FinalReferenceEscapeExample();
    }
    
    public static void reader() {
        if (obj != null) {              // 3 
            int temp = obj.i;           // 4
        }
    }
}

假设线程A执行writer()方法，线程B执行reader()方法。这里的操作2使得对象还未完成构造前就被线程B可见。即使操作2放到了构造函数的最后一步，且在程序中操作2排在了1后面，执行reader()方法的线程仍可能无法看到final域被初始化后的值，因为操作1和操作2可能被重排序。

从上面的图可以看出：在构造函数返回前，被构造对象的引用不能为其他线程所见，因为此时的final域可能还没有被初始化。在构造函数返回后，任意线程都保证能看到final域正确初始化后的值。

6.final语义在处理器中的实现

上面介绍了写final域的重排序规则会要求编译器在final域的写入后，构造函数返回之前插入一个StoreStore屏障。读final域的重排序规则要求编译器在读final域的操作前插入一个LoadLoad屏障。但X86处理器不会对写-写操作做重排序，所以StoreStore屏障被省略。X86处理器不会对存在间接依赖关系的操作做重排序，所以读final域需要的LoadLoad屏障也会被省略。即x86处理器，final域的读写不会插入任何内存屏障。

7.JSR-133为什么要加强final的语义

插曲：JSR-133即JDK5开始。

在旧的JMM中，有个弊端是线程可能看到final域的值会改变。比如一个线程当前看到一个整形final域的值为0（还未初始化之前的默认值），过一段时间这个线程再读取这个final值，发现为1（被某个线程初始化之后的值），作者举了个例子是在旧的JMM中String的值可能会改变。

所以JSR-133的专家们增强了final的语义，通过给final域增加写和读重排序规则，可以提供初始化安全保证：只要对象时正确构造的（被构造对象的引用在构造函数中没有“逸出”），就不需要使用同步就可以保证在任意线程都能看到这个final域在构造函数中被初始化后的值。