问题
一个线程向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写 |
普通读/写 | 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
- 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能读取到几乎最新的数据,虽然可能不是最新的。要得到最新的数据,只有采用完全的同步。
欢迎关注公众号: