Java Volatile(包含对volatile数组和对象的理解)

时间：2021-07-14 20:04:38

1.多线程中重要概念

1.1 可见性
也就说假设一个对象中有一个变量i，那么i是保存在main memory中的，当某一个线程要操作i的时候，首先需要从main memory中将i 加载到这个线程的working memory中，这个时候working memory中就有了一个i的拷贝，这个时候此线程对i的修改都在其working memory中，直到其将i从working memory写回到main memory中，新的i的值才能被其他线程所读取。从某个意义上说，可见性保证了各个线程的working memory的数据的一致性。
可见性遵循下面一些规则：

当一个线程运行结束的时候，所有写的变量都会被flush回main memory中。
当一个线程第一次读取某个变量的时候，会从main memory中读取最新的。
volatile的变量会被立刻写到main memory中的，在jsr133中，对volatile的语义进行增强，后面会提到
当一个线程释放锁后，所有的变量的变化都会flush到main memory中，然后一个使用了这个相同的同步锁的进程，将会重新加载所有的使用到的变量，这样就保证了可见性。
1.2 原子性
还拿上面的例子来说，原子性就是当某一个线程修改i的值的时候，从取出i到将新的i的值写给i之间不能有其他线程对i进行任何操作。也就是说保证某个线程对i的操作是原子性的，这样就可以避免数据脏读。
通过锁机制或者CAS（Compare And Set 需要硬件CPU的支持）操作可以保证操作的原子性。

1.3 有序性
假设在main memory中存在两个变量i和j，初始值都为0，在某个线程A的代码中依次对i和j进行自增操作（i，j的操作不相互依赖），


i++;
j++;
由于，所以i,j修改操作的顺序可能会被重新排序。那么修改后的ij写到main memory中的时候，顺序可能就不是按照i，j的顺序了，这就是所谓的reordering，在单线程的情况下，当线程A运行结束的后i，j的值都加1了，在线程自己看来就好像是线程按照代码的顺序进行了运行（这些操作都是基于as-if-serial语义的），即使在实际运行过程中，i，j的自增可能被重新排序了，当然计算机也不能帮你乱排序，存在上下逻辑关联的运行顺序肯定还是不会变的。但是在多线程环境下，问题就不一样了，比如另一个线程B的代码如下


if(j==1) {
    System.out.println(i);
}
按照我们的思维方式，当j为1的时候那么i肯定也是1，因为代码中i在j之前就自增了，但实际的情况有可能当j为1的时候i还是为0。这就是reorderin*生的不好的后果，所以我们在某些时候为了避免这样的问题需要一些必要的策略，以保证多个线程一起工作的时候也存在一定的次序。JMM提供了happens-before 的排序策略。

 

2. JMM(java内存模型)

    Java 内存模型的抽象 

在java中，所有实例域、静态域和数组元素存储在堆内存中，堆内存在线程之间共享（本文使用“共享变量”这个术语代指实例域，静态域和数组元素）。局部变量（Local variables），方法定义参数（java语言规范称之为formal method parameters）和异常处理器参数（exception handler parameters）不会在线程之间共享，它们不会有内存可见性问题，也不受内存模型的影响。

 

Java线程之间的通信由Java内存模型（本文简称为JMM）控制，JMM决定一个线程对共享变量的写入何时对另一个线程可见。从抽象的角度来看，JMM定义了线程和主内存之间的抽象关系：线程之间的共享变量存储在主内存（main memory）中，每个线程都有一个私有的本地内存（local memory），本地内存中存储了该线程以读/写共享变量的副本。本地内存是JMM的一个抽象概念，并不真实存在。它涵盖了缓存，写缓冲区，寄存器以及其他的硬件和编译器优化。Java内存模型的抽象示意图如下：

 

Java Volatile(包含对volatile数组和对象的理解)

 

从上图来看，线程A与线程B之间如要通信的话，必须要经历下面2个步骤：

 

  1. 首先，线程A把本地内存A中更新过的共享变量刷新到主内存中去。
  2. 然后，线程B到主内存中去读取线程A之前已更新过的共享变量。

 

下面通过示意图来说明这两个步骤：

 

Java Volatile(包含对volatile数组和对象的理解)

 

如上图所示，本地内存A和B有主内存*享变量x的副本。假设初始时，这三个内存中的x值都为0。线程A在执行时，把更新后的x值（假设值为1）临时存放在自己的本地内存A中。当线程A和线程B需要通信时，线程A首先会把自己本地内存中修改后的x值刷新到主内存中，此时主内存中的x值变为了1。随后，线程B到主内存中去读取线程A更新后的x值，此时线程B的本地内存的x值也变为了1。

 

从整体来看，这两个步骤实质上是线程A在向线程B发送消息，而且这个通信过程必须要经过主内存。JMM通过控制主内存与每个线程的本地内存之间的交互，来为java程序员提供内存可见性保证。

 

3. Volatile

对一个共享变量使用Volatile关键字保证了线程间对该数据的可见性，即不会读到脏数据。

注：1. 可见性：对一个volatile变量的读，总是能看到（任意线程）对这个volatile变量最后的写入

        2. 原子性：对任意单个volatile变量的读/写具有原子性(long,double这2个8字节的除外)，但类似于volatile++这种复合操作不具有原子性。

        3. volatile修饰的变量如果是对象或数组之类的，其含义是对象获数组的地址具有可见性，但是数组或对象内部的成员改变不具备可见性：

            eg：以下代码要以-server模式运行，强制虚拟机开启优化

[java] view plain copy
  1. package com.xj;  
  2.   
  3. public class VolatileObjectTest implements Runnable {  
  4.     private ObjectA a; // <span style="color:#ff0000;"><strong>加上volatile 就可以正常结束While循环了  </strong></span>   
  5.     public VolatileObjectTest(ObjectA a) {  
  6.         this.a = a;  
  7.     }  
  8.    
  9.     public ObjectA getA() {  
  10.         return a;  
  11.     }  
  12.    
  13.     public void setA(ObjectA a) {  
  14.         this.a = a;  
  15.     }  
  16.    
  17.     @Override  
  18.     public void run() {  
  19.         long i = 0;  
  20.         while (a.isFlag()) {  
  21.             i++;  
  22. //            System.out.println("------------------");  
  23.         }  
  24.         System.out.println("stop My Thread " + i);  
  25.     }  
  26.    
  27.     public void stop() {  
  28.         a.setFlag(false);  
  29.     }  
  30.    
  31.     public static void main(String[] args) throws InterruptedException {  
  32.          // 如果启动的时候加上-server 参数则会 输出 Java HotSpot(TM) Server VM  
  33.         System.out.println(System.getProperty("java.vm.name"));  
  34.            
  35.         VolatileObjectTest test = new VolatileObjectTest(new ObjectA());  
  36.         new Thread(test).start();  
  37.    
  38.         Thread.sleep(1000);  
  39.         test.stop();  
  40.         Thread.sleep(1000);  
  41.         System.out.println("Main Thread " + test.getA().isFlag());  
  42.     }  
  43.    
  44.     static class ObjectA {  
  45.         private boolean flag = true;  
  46.    
  47.         public boolean isFlag() {  
  48.             return flag;  
  49.         }  
  50.    
  51.         public void setFlag(boolean flag) {  
  52.             this.flag = flag;  
  53.         }  
  54.    
  55.     }  
  56. }  

       以上代码如果是红色标记那一行加volatile关键字，子线程是可以退出循环的，不加的话，子线程没法退出循环，如此说来，volatile变量修饰对象或者数组，当我们改变对象或者数组的成员的时候，岂非不同线程之间具有可见性？

      在看如下代码：

[java] view plain copy
  1. package com.xj;  
  2.   
  3. public class VolatileTestAgain implements Runnable {  
  4.     private <span style="color:#ff0000;"><strong>volatile</strong></span> ObjectA a; // <span style="color:#ff0000;"><strong>加上volatile也无法结束While循环了</strong>  
  5. </span>   
  6.     public VolatileTestAgain(ObjectA a) {  
  7.         this.a = a;  
  8.     }  
  9.    
  10.     public ObjectA getA() {  
  11.         return a;  
  12.     }  
  13.    
  14.     public void setA(ObjectA a) {  
  15.         this.a = a;  
  16.     }  
  17.    
  18.     @Override  
  19.     public void run() {  
  20.         long i = 0;  
  21.         ObjectASub sub = a.getSub();  
  22.         while (!sub.isFlag()) {  
  23.             i++;        }  
  24.         System.out.println("stop My Thread " + i);  
  25.     }  
  26.     
  27.     public static void main(String[] args) throws InterruptedException {  
  28.          // 如果启动的时候加上-server 参数则会 输出 Java HotSpot(TM) Server VM  
  29.         System.out.println(System.getProperty("java.vm.name"));  
  30.         ObjectASub <span style="color:#ff0000;">sub</span> = new ObjectASub();  
  31.         ObjectA sa = new ObjectA();  
  32.         sa.setSub(sub);  
  33.         VolatileTestAgain test = new VolatileTestAgain(sa);  
  34.         new Thread(test).start();  
  35.    
  36.         Thread.sleep(1000);  
  37.         sub.setFlag(true);  
  38.         Thread.sleep(1000);  
  39.         System.out.println("Main Thread " + sub.isFlag());  
  40.     }  
  41.    
  42.     static class ObjectA {  
  43.         private ObjectASub sub;  
  44.   
  45.         public ObjectASub getSub() {  
  46.             return sub;  
  47.         }  
  48.   
  49.         public void setSub(ObjectASub sub) {  
  50.             this.sub = sub;  
  51.         }  
  52.     }  
  53.       
  54.     static class ObjectASub{  
  55.         private boolean flag;  
  56.   
  57.         public boolean isFlag() {  
  58.             return flag;  
  59.         }  
  60.   
  61.         public void setFlag(boolean flag) {  
  62.             this.flag = flag;  
  63.         }  
  64.           
  65.           
  66.     }  
  67. }  

      如上代码即使添加volatile关键字也无法让子线程结束循环，读者可以仔细对比一下2段代码，下面是我的解释。

     1）代码1中当主线程更改flag字段时候，是调用stop()方法里面的“a.setFlag(false); ”，注意这一句其实包含多步操作，含义丰富：首先是对volatile变量a的读，既然是volatile变量，当然读到的是主存(而不是线程私有的)中的地址,然后再setFlag来更新这个标志位实际上是更新的主存中引用指向的堆内存；然后是子线程读

a.isFlag()，同样的包含多步：首先是对volatile变量的读，当然读的是主存中的引用地址，然后根据这个引用找堆内存中flag值，当然找到的就是之前主线程写进去的值，所以能够立即生效，子线程退出。

    2）代码1中虽然主线程和子线程都是读volatile值，然后一个是改，一个是读，按照java内存模型中的happen-before，2个线程对volatile变量的读是不具有happen-before特性的，但是这里要注意的是，因为都是以volatile变量为根，层层引用，最后找到的都是同一块堆内存，然后一个修改，一个查看，所以实际上相当于同一个线程在写和修改（因为写和修改的是同一块内存）；所以可以利用happen-before中第一条规则——程序顺序规则，从而有主线程的写happen-before子线程的读

    3）代码2中加了volatile关键字仍然子线程无法退出，这是因为主线程的对flag标志位的改，已经不是通过volatile根对象先定位到主存中的地址，然后逐级索引去找到堆内存，然后改地址，而是直接在线程中保存了一个sub对象，这样改掉的，实际上不是主存中的volatile根对象引用的ObjectASub对象再引用的flag标志位的值了，他改变的是本地线程中缓存的值；同理子线程中取的也是每次都取的本地线程中缓存的值；主线程的写没有及时刷新到主存中，子线程也没用从主存中去读，导致了数据的不一致性。

    总结：1）用volatile修饰数组和对象不是不可以，要注意一点：修改操作要从volatile变量逐级引用，去找到要修改的变量，保证修改是刷新到主存中的值对应的变量；读取操作，也要以volatile变量为根，逐级去定位，这样保证修改即使刷新到主存中volatile变量指向的堆内存，读取能够每次从主存的volatile变量指向的堆内存去读，保证数据的一致性。

                2）在保证了总结1）的前提下，因为大家读取修改的都是同一块内存，所以变相的符合happen-before规则中的程序顺序规则，具有happen-before性。

      3. volatile写-读建立的happens before关系

              对程序员来说，volatile对线程的内存可见性的影响比volatile自身的特性更为重要，也更需要我们去关注.

             happen-before规则：

             程序顺序规则：一个线程中的每个操作，happens- before 于该线程中的任意后续操作。 
             监视器锁规则：对一个监视器锁的解锁，happens- before 于随后对这个监视器锁的加锁。 
             volatile变量规则：对一个volatile域的写，happens- before 于任意后续对这个volatile域的读。
            传递性：如果A happens- before B，且B happens- before C，那么A happens- before C。
             Thread.start()的调用会happens-before于启动线程里面的动作。 
             Thread中的所有动作都happens-before于其他线程从Thread.join中成功返回。

            

             进一步关注JMM如何实现volatile写/读的内存语义

            前文我们提到过重排序分为编译器重排序和处理器重排序。为了实现volatile内存语义，JMM会分别限制这两种类型的重排序类型。下面是JMM针对编译器制定的volatile

            重排序规则表：

是否能重排序 第二个操作
第一个操作 普通读/写 volatile读 volatile写
普通读/写     NO
volatile读 NO NO NO
volatile写   NO NO

举例来说，第三行最后一个单元格的意思是：在程序顺序中，当第一个操作为普通变量的读或写时，如果第二个操作为volatile写，则编译器不能重排序这两个操作。


从上表我们可以看出：
当第二个操作是volatile写时，不管第一个操作是什么，都不能重排序。这个规则确保volatile写之前的操作不会被编译器重排序到volatile写之后。
当第一个操作是volatile读时，不管第二个操作是什么，都不能重排序。这个规则确保volatile读之后的操作不会被编译器重排序到volatile读之前。
当第一个操作是volatile写，第二个操作是volatile读时，不能重排序。

当第一个操作是volatile写，第二个操作是volatile读时，不能重排序。

     eg：（对以上volatile的happen-before特性的利用）

java并发库ConcurrentHashMap中get操作的无锁弱一致性实现

[java] view plain copy
  1. V get(Object key, int hash) {     
  2.     <span style="color:#ff0000;"><strong>if (count != 0) { // read-volatile</strong>     
  3. </span>        HashEntry<K,V> e = getFirst(hash);     
  4.         while (e != null) {     
  5.             if (e.hash == hash && key.equals(e.key)) {     
  6.                 V v = e.value;     
  7.                 if (v != null)     
  8.                     return v;     
  9.                 return readValueUnderLock(e); // recheck     
  10.             }     
  11.             e = e.next;     
  12.         }     
  13.     }     
  14.     return null;     
  15. }    
 [java] view plain copy
  1. V put(K key, int hash, V value, boolean onlyIfAbsent) {  
  2.            lock();  
  3.            try {  
  4.                int c = count;  
  5.                if (c++ > threshold) // ensure capacity  
  6.                    rehash();  
  7.                HashEntry<K,V>[] tab = table;  
  8.                int index = hash & (tab.length - 1);  
  9.                HashEntry<K,V> first = tab[index];  
  10.                HashEntry<K,V> e = first;  
  11.                while (e != null && (e.hash != hash || !key.equals(e.key)))  
  12.                    e = e.next;  
  13.   
  14.                V oldValue;  
  15.                if (e != null) {  
  16.                    oldValue = e.value;  
  17.                    if (!onlyIfAbsent)  
  18.                        e.value = value;  
  19.                }  
  20.                else {  
  21.                    oldValue = null;  
  22.                    ++modCount;  
  23.                    tab[index] = new HashEntry<K,V>(key, hash, first, value);  
  24.                    <span style="color:#ff0000;">count = c; // write-volatile  
  25. lt;/span>                }  
  26.                return oldValue;  
  27.            } finally {  
  28.                unlock();  
  29.            }  
  30.        }  

get操作不需要锁。第一步是访问count变量，这是一个volatile变量，由于所有的修改操作在进行结构修改时都会在最后一步写count变量，通过这种机制保证get操作能够得到几乎最新的结构更新。对于非结构更新，也就是结点值的改变，由于HashEntry的value变量是volatile的，也能保证读取到最新的值。接下来就是对hash链进行遍历找到要获取的结点，如果没有找到，直接访回null。对hash链进行遍历不需要加锁的原因在于链指针next是final的。但是头指针却不是final的，这是通过getFirst(hash)方法返回，也就是存在table数组中的值。这使得getFirst(hash)可能返回过时的头结点，例如，当执行get方法时，刚执行完getFirst(hash)之后，另一个线程执行了删除操作并更新头结点，这就导致get方法中返回的头结点不是最新的。这是可以允许，通过对count变量的协调机制，get能读取到几乎最新的数据，虽然可能不是最新的。要得到最新的数据，只有采用完全的同步。

标签：

相关文章