【并发】volatile是否能保证数组中元素的可见性？

来源：互联网发布：js 数组中删除元素编辑：程序博客网时间：2024/06/15 19:11

问题

一个线程向volatile的数组中设置值，而另一个线程向volatile的数组中读取。
比如seg.setValue(2)，随后另一个线程调用seg.getValue(2)，前一个线程设置的值对读取的线程是可见的吗？

我看书上说volatile的数组只针对数组的引用具有volatile的语义，而不是它的元素。

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

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

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

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

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

[java] view plain copy
package com.xj;  
  
public class VolatileObjectTest implements Runnable {  
    private ObjectA a; // <span style="color:#ff0000;"><strong>加上volatile 就可以正常结束While循环了  </strong></span>   
    public VolatileObjectTest(ObjectA a) {  
        this.a = a;  
    }  
   
    public ObjectA getA() {  
        return a;  
    }  
   
    public void setA(ObjectA a) {  
        this.a = a;  
    }  
   
    @Override  
    public void run() {  
        long i = 0;  
        while (a.isFlag()) {  
            i++;  
//            System.out.println("------------------");  
        }  
        System.out.println("stop My Thread " + i);  
    }  
   
    public void stop() {  
        a.setFlag(false);  
    }  
   
    public static void main(String[] args) throws InterruptedException {  
         // 如果启动的时候加上-server 参数则会 输出 Java HotSpot(TM) Server VM  
        System.out.println(System.getProperty("java.vm.name"));  
           
        VolatileObjectTest test = new VolatileObjectTest(new ObjectA());  
        new Thread(test).start();  
   
        Thread.sleep(1000);  
        test.stop();  
        Thread.sleep(1000);  
        System.out.println("Main Thread " + test.getA().isFlag());  
    }  
   
    static class ObjectA {  
        private boolean flag = true;  
   
        public boolean isFlag() {  
            return flag;  
        }  
   
        public void setFlag(boolean flag) {  
            this.flag = flag;  
        }  
   
    }  
}  

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

在看如下代码：

[java] view plain copy
package com.xj;  
  
public class VolatileTestAgain implements Runnable {  
    private <span style="color:#ff0000;"><strong>volatile</strong></span> ObjectA a; // <span style="color:#ff0000;"><strong>加上volatile也无法结束While循环了</strong>  
</span>   
    public VolatileTestAgain(ObjectA a) {  
        this.a = a;  
    }  
   
    public ObjectA getA() {  
        return a;  
    }  
   
    public void setA(ObjectA a) {  
        this.a = a;  
    }  
   
    @Override  
    public void run() {  
        long i = 0;  
        ObjectASub sub = a.getSub();  
        while (!sub.isFlag()) {  
            i++;        }  
        System.out.println("stop My Thread " + i);  
    }  
    
    public static void main(String[] args) throws InterruptedException {  
         // 如果启动的时候加上-server 参数则会 输出 Java HotSpot(TM) Server VM  
        System.out.println(System.getProperty("java.vm.name"));  
        ObjectASub <span style="color:#ff0000;">sub</span> = new ObjectASub();  
        ObjectA sa = new ObjectA();  
        sa.setSub(sub);  
        VolatileTestAgain test = new VolatileTestAgain(sa);  
        new Thread(test).start();  
   
        Thread.sleep(1000);  
        sub.setFlag(true);  
        Thread.sleep(1000);  
        System.out.println("Main Thread " + sub.isFlag());  
    }  
   
    static class ObjectA {  
        private ObjectASub sub;  
  
        public ObjectASub getSub() {  
            return sub;  
        }  
  
        public void setSub(ObjectASub sub) {  
            this.sub = sub;  
        }  
    }  
      
    static class ObjectASub{  
        private boolean flag;  
  
        public boolean isFlag() {  
            return flag;  
        }  
  
        public void setFlag(boolean flag) {  
            this.flag = flag;  
        }  
          
          
    }  
}  

如上代码即使添加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写普通读/写 NOvolatile读NONONOvolatile写 NONO

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

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

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

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

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

[java] view plain copy
V get(Object key, int hash) {     
    <span style="color:#ff0000;"><strong>if (count != 0) { // read-volatile</strong>     
</span>        HashEntry<K,V> e = getFirst(hash);     
        while (e != null) {     
            if (e.hash == hash && key.equals(e.key)) {     
                V v = e.value;     
                if (v != null)     
                    return v;     
                return readValueUnderLock(e); // recheck     
            }     
            e = e.next;     
        }     
    }     
    return null;     
}    

[java] view plain copy
V put(K key, int hash, V value, boolean onlyIfAbsent) {  
           lock();  
           try {  
               int c = count;  
               if (c++ > threshold) // ensure capacity  
                   rehash();  
               HashEntry<K,V>[] tab = table;  
               int index = hash & (tab.length - 1);  
               HashEntry<K,V> first = tab[index];  
               HashEntry<K,V> e = first;  
               while (e != null && (e.hash != hash || !key.equals(e.key)))  
                   e = e.next;  
  
               V oldValue;  
               if (e != null) {  
                   oldValue = e.value;  
                   if (!onlyIfAbsent)  
                       e.value = value;  
               }  
               else {  
                   oldValue = null;  
                   ++modCount;  
                   tab[index] = new HashEntry<K,V>(key, hash, first, value);  
                   <span style="color:#ff0000;">count = c; // write-volatile  
lt;/span>                }  
               return oldValue;  
           } finally {  
               unlock();  
           }  
       }  

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能读取到几乎最新的数据，虽然可能不是最新的。要得到最新的数据，只有采用完全的同步。

0 0