java内存模型关键字 final 的内存语义（三十五）

喜欢ヅ旅行 2023-01-01 01:58 149阅读 0赞

今天分析 java 内存模型 中 关键字 final 的内存语义：

在构造线程的类时，我们有种方式就是让类中所有的成员变量都不可变，利 用的就是 final  关键字，那么这个  final  为何可以做到呢？重排序这种优化动作对 构造方法，一样也是存在的。这就说明，一个成员变量加了 final  关键字后， JMM 一定是做了相关处理的。

**1、final**  **的两个重排序规则**

对应  final  域，编译器和处理器需要遵守两个重排序规则。我们以下面代码为例：

/**
     * 类说明：final的内存语义
     */
    public class FinalMemory {
        int i;                      // 普通变量
        final int j;                // final变量
        static FinalMemory obj;
    
        public FinalMemory() {    // 构造函数
            i = 1;                 // 写普通域
            j = 2;                 // 写final域
        }
    
        public static void writer() {// 写线程A执行
            obj = new FinalMemory();
        }
    
        public static void reader() {   // 读线程B执行
            FinalMemory object = obj;  // 读对象引用
            int a = object.i;           // 读普通域
            int b = object.j;           // 读final域
        }
    }

我们假设一个线程 A 执行 writer 方法，随后另一个线程 B 执行 reader 方法。

1 、在构造函数内对一个  final  域的写入，与随后把这个被构造对象的引用赋 值给一个引用变量，这两个操作之间不能重排序。 看 write() 方法，只包含一行代码  *obj*  =  **new**  FinalMemory(); 。这一行代码包含

两个步骤：

构造一个  FinalMemory  类型的对象。

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

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70][]

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

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

2 、初次读一个包含  final  域的对象的引用，与随后初次读这个  final  域，这两 个操作之间不能重排序 在一个线程中，**初次读对象引用与初次读该对象包含的**  **final**  **域** ， JMM  禁止

处理器重排序这两个操作。 **编译器会在读**  **final**  **域操作的前面插入一个**  **LoadLoad**  **屏障** 。

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

初次读引用变量  obj

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

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

我们假设写线程  A  没有发生任何重排序，则下图是一种可能的时序：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70 1][]

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

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

**2、final**  **域为引用类型**

/**
     * 类说明：
     */
    public class FinalRefMemory {
        final int[] intArray;       // final 是引用类型
        static FinalRefMemory obj;
    
        public FinalRefMemory() {   // 构造函数
            intArray = new int[1];         // 1
            intArray[0] = 1;               // 2
        }
    
        public static void writerOne() {   // 写线程A执行
            obj = new FinalRefMemory();// 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 域是一个引用类型，它引用了一个 int 类型的数组， 对于引用类型，写 final 域的重排序规则对编译器和处理器增加了一下的约束： 在构造函数内对一个 final 引用的对象的成员域的写入，与随后在构造函数外把 这个被构造对象的引用赋值给一个引用变量，这两个操作之间不能重排序。 我们假设线程 A 先执行 write0 操作，执行完后线程 B 执行 write1 操作，执 行完后线程 C 执行 reader 操作，下图是一种可能的执行时序：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70 2][]

1  是对  final  域的写入，

2  是对这个  final  域引用的对象的成员域的写入，

3  是 把被构造的对象的引用赋值给某个引用变量。这里除了前面提到的 1  不能和  3 重排序外，2  和  3  也不能重排序。

JMM  可以确保读线程  C  至少能看到写线程  A  在构造函数中对  final  引用对象 的成员域的写入。即 C  至少能看到数组下标  0  的值为  1 。而写线程  B  对数组元素 的写入，读线程 C  可能看得到，也可能看不到。 JMM  不保证线程  B  的写入对读 线程 C  可见，因为写线程  B  和读线程  C  之间存在数据竞争，此时的执行结果不可 预知。

如果想要确保读线程  C  看到写线程  B  对数组元素的写入，写线程  B  和读线 程 C  之间需要使用同步（ lock  或  volatile ）来确保内存可见性。

**3、final**  **引用不能从构造函数内逃逸**

写  final  域的重排序规则可以确保：在引用变量为任意线程可见之前，该引 用变量指向的对象的 final  域已经在构造函数中被正确初始化过了。其实，要得到这个效果，还需要一个保证：在构造函数内部，不能让这个被构造对象的引用 为其他线程所见，也就是对象引用不能在构造函数中逃逸。

我们以 代码 为例来说明

/**
     * 类说明：不能让final引用从构造方法中溢出
     */
    public class FinalEscape {
        final int i;
        static FinalEscape obj;
    
        public FinalEscape() {
            i = 10;         //写final域
            obj = this;     //this引用溢出
        }
    
        public static void writer(){
            new FinalEscape();
        }
    
        public static void reader(){
            if(obj!=null){          //3
                int temp = obj.i;   //4
            }
        }
    }

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70 3][]

因此在构造函数返回前，被构造对象的引用不能为其他线程所见，因为此时 的 final  域可能还没有被初始化。

**4、final**  **语义的实现**

会要求编译器在  final  域的写之后，构造函数  return  之前插入一个  StoreStore 障屏。读 final  域的重排序规则要求编译器在读  final  域的操作前面插入一个 LoadLoad 屏障

java内存模型 关键字 final 的内存语义分析完成。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70]: /images/20221120/91f9c23b20e142dcb57b555f9679e80b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70 1]: /images/20221120/6c95c442930f4dbc8d74c5d4050d2d4e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70 2]: /images/20221120/80312f8d70c14005be58c342a08a91ae.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70 3]: /images/20221120/352c0f1f3073400eafb1de9da6798600.png