zoukankan      html  css  js  c++  java
  • Java并发编程原理与实战四十四:final域的内存语义

    一.final域的重排序规则

      对于final域,编译器和处理器要遵循两个重拍序规则:
      1.在构造函数内对一个final域的写入,与随后把这个被构造对象的引用赋值给一个引用变量,这两个操作之间不能重排序。

      2.初次读一个包含final域的对象的应用,与随后初次读这个final域,这两个操作之间不能重排序

      下面通过一个示例来分别说明这两个规则:

    public class FinalTest {
        int i;//普通变量
        final int j;
        static FinalTest obj;
    
        public FinalTest(){
            i = 1;
            j = 2;
        }
    
        public static void writer(){
            obj = new FinalTest();
        }
    
        public static void reader(){
            FinalTest tets = obj;//读对象引用
            int a = tets.i;
            int b = tets.j;
        }
    }

      这里假设一个线程A执行writer方法,随后另一个线程B执行reader方法。我们通过这两个线程的交互来说明这两个规则。

      写final域的重排序规则禁止把final域的写重排序到构造函数之外。这个规则的实现包含两个方面:

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

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

      现在让我们分析writer方法,writer方法只包含一行代码obj = new FinalTest();这行代码包含两个步骤:
        1.构造一个FinalTest类型的对象

        2.把这个对象的引用赋值给obj

      假设线程B的读对象引用与读对象的成员域之间没有重排序,下图是一种可能的执行时序

      

      在上图中,写普通域的操作被编译器重排序到了构造函数之外,读线程B错误的读取到了普通变量i初始化之前的值。而写final域的操作被写final域重排序的规则限定在了构造函数之内,读线程B正确的读取到了final变量初始化之后的值。

      写final域的重排序规则可以确保:在对象引用为任意线程可见之前,对象的final域已经被初始化了,而普通变量不具有这个保证。以上图为例,读线程B看到对象obj的时候,很可能obj对象还没有构造完成(对普通域i的写操作被重排序到构造函数外,此时初始值1还没有写入普通域i)

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

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

      上面的例子中,reader方法包含三个操作

        1.初次读引用变量obj

        2.初次读引用变量指向对象的普通域

        3.初次读引用变量指向对象的final域

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

      

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

      读final域的重排序规则可以确保:在读一个对象的final域之前,一定会先读包含这个final域的对象的引用。在这个示例程序中,如果该引用不为null,那么引用对象的final域一定已经被A线程初始化过了。

    二.final域为引用类型

      上述将的final域都是基本类型,如果final域是引用类型,会有什么效果呢?

      

    public class FinalReferenceTest {
    
        final int[] arrs;//final引用
    
        static FinalReferenceTest obj;
    
        public FinalReferenceTest(){
            arrs = new int[1];//1
            arrs[0] = 1;//2
        }
    
        public static void write0(){//A线程
            obj = new FinalReferenceTest();//3
        }
    
        public static void write1(){//线程B
            obj.arrs[0] = 2;//4
        }
    
        public static void reader(){//C线程
            if(obj!=null){//5
                int temp =obj.arrs[0];//6
            }
        }
    }

      在上述的例子中,final域是一个引用类型,它引用了一个int类型的数组,对于引用类型,写final域的重排序规则对编译器和处理器增加了一下的约束:在构造函数内对一个final引用的对象的成员域的写入,与随后在构造函数外把这个被构造对象的引用赋值给一个引用变量,这两个操作之间不能重排序。

      本例中假设线程A先执行write0操作,执行完后线程B执行write1操作,执行完后线程C执行reader操作,下图是一种可能的执行时序:
      

      上图中:,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)来确保内存可见性。

      前面我们提到过,写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后面,执行read()方法的线程仍然可能无法看到final域被初始化后的值,因为这里的操作1和操作2之间可能被重排序。实际的执行时序可能如下:

      

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

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

      现在我们以X86处理器为例,说明final语义在处理器中的具体实现.

      上面我们提到,写final域的重排序规则会要求编译器在final域的写之后,构造函数return之前插入一个StoreStore障屏。读final域的重排序规则要求编译器在读final域的操作前面插入一个LoadLoad屏障。由于X86处理器不会对写-写操作做重排序,所以在X86处理器中,写final域需要的StoreStore障屏会被省略掉。同样,由于X86处理器不会对存在间接依赖关系的操作做重排序,所以在X86处理器中,读final域需要的LoadLoad屏障也会被省略掉。也就是说,在X86处理器
    中,final域的读/写不会插入任何内存屏障。

      在旧的Java内存模型中,一个最严重的缺陷就是线程可能看到final域的值会改变。比如,一个线程当前看到一个整型final域的值为0(还未初始化之前的默认值),过一段时间之后这个线程再去读这个final域的值时,却发现值变为1(被某个线程初始化之后的值)。最常见的例子就是在旧的Java内存模型中,String的值可能会改变。为了修补这个漏洞,JSR-133专家组增强了final的语义。通过为final域增加写和读重排序规则,可以为Java程序员提供初始化安全保证:只要对象是正确构造的(被构造对象的引用在构造函数中没有“逸出”),那么不需要使用同步(指lock和volatile的使用)就可以保证任意线程都能看到这个final域在构造函数中被初始化之后的值。

    参考资料:

    https://blog.csdn.net/ditto_zhou/article/details/78738197

    https://blog.csdn.net/dam454450872/article/details/80385520

    http://www.itdaan.com/index.html

  • 相关阅读:
    springboot springcloud zuul 过滤器
    springboot springcloud eureka 熔断器
    javaweb servlet filter
    maven nexus 搭建私服(二)
    springboot springcloud zuul 网关入门
    springboot springcloud 配置中心
    springboot springcloud eureka 入门
    java rabbitmq
    java jvm调优
    maven nexus 搭建私服(一)
  • 原文地址:https://www.cnblogs.com/pony1223/p/9567484.html
Copyright © 2011-2022 走看看