volatile修饰数组

Posted 2021-06-09 walker993

之前读CHM的源码(JDK8)，其中有一段印象比较深，它内部有一个Node数组，volatile修饰， transient volatile Node<K,V>[] table; 。而Node对象本身，存储数据的val变量，也是用volatile修饰的。这两个一个是保证扩容时，变更table引用时的可见性，一个是保证value修改后的可见性。

1. 非volatile数组的可见性问题

　　实验一：

 1 public class Test {
 2     static int[] a = new int[]{1};
 3 
 4     public static void main(String[] args) {
 5         new Thread(() -> {
 6             System.out.println("线程1开始休眠：" + LocalDateTime.now().toString());
 7             try {
 8                 Thread.sleep(1000);
 9             } catch (InterruptedException e) {
10                 e.printStackTrace();
11             }
12             System.out.println("线程1休眠结束：" + LocalDateTime.now().toString());
13             a[0] = 0;
14         }).start();
15 
16         while (a[0] != 0) {
17         }
18         System.out.println("主线程退出循环：" + LocalDateTime.now().toString());
19     }
20 }

　　上述代码测试时，主线程无法退出循环，这说明了主线程使用的一直是工作内存中的数组数据，没有从主存刷新数据。

　　多线程下，修改普通数组，是不可见的。

　　实验二：

1 while (a[0] != 0) {
2     System.out.println("");
3 }
4 System.out.print("主线程退出循环：" + LocalDateTime.now().toString());

　　修改实验一的部分代码，神奇的事情发生了 

　　

　　竟然可以了？

　　实验三：　　

 1 public class Test {
 2     static int[] a = new int[]{1};
 3     static volatile boolean b = false;
 4 
 5     public static void main(String[] args) {
 6         new Thread(() -> {
 7             System.out.println("线程1开始休眠：" + LocalDateTime.now().toString());
 8             try {
 9                 Thread.sleep(1000);
10             } catch (InterruptedException e) {
11                 e.printStackTrace();
12             }
13             System.out.println("线程1休眠结束：" + LocalDateTime.now().toString());
14             a[0] = 0;
15         }).start();
16 
17         while (a[0] != 0) {
18             b = false;
19         }
20         System.out.println("主线程退出循环：" + LocalDateTime.now().toString());
21     }
22 }

　　参考资料中提到，当线程读取一个volatile修饰的变量时，会将这个线程中所有的变量都从主存中刷新一下。所以这里主线程访问变量b时，也会同时刷新数组。

　　　　

2. volatile数组的可见性问题

　　实验三：

 1 public class Test {
 2     static volatile int[] a = new int[]{1};
 3 
 4     public static void main(String[] args) {
 5         new Thread(() -> {
 6             System.out.println("线程1开始休眠：" + LocalDateTime.now().toString());
 7             try {
 8                 Thread.sleep(1000);
 9             } catch (InterruptedException e) {
10                 e.printStackTrace();
11             }
12             System.out.println("线程1休眠结束：" + LocalDateTime.now().toString());
13             a[0] = 0;
14         }).start();
15 
16         while (a[0] != 0) {
17         }
18         System.out.println("主线程退出循环：" + LocalDateTime.now().toString());
19     }
20 }

　　主线程正常退出，那么问题来了，volatile到底只保证引用的可见性，还是包含了引用指向对象的可见性？

　　

3. volatile修饰数组的作用

　　在网上查阅资料，说这里需要区分一下基础类型数组和对象类型数组。上面的实验都是基于整数数组，那我们继续实验一下对象数组

　　实验四：

 1 public class Test {
 2     static volatile A[] a = new A[]{new A(1)};
 3 
 4     public static void main(String[] args) {
 5         new Thread(() -> {
 6             System.out.println("线程1开始休眠：" + LocalDateTime.now().toString());
 7             try {
 8                 Thread.sleep(1000);
 9             } catch (InterruptedException e) {
10                 e.printStackTrace();
11             }
12             System.out.println("线程1休眠结束：" + LocalDateTime.now().toString());
13             a[0] = new A(0);
14         }).start();
15 
16         while (a[0].val == 0) {
17         }
18         System.out.println("主线程退出循环：" + LocalDateTime.now().toString());
19     }
20 
21 
22     static class A {
23         public int val;
24 
25         A(int val) {
26             this.val = val;
27         }
28     }
29 }

　　很遗憾，跟实验三的结果是一样的。

　　那么为什么CHM需要再使用volatile保证Node对象value属性的可见性呢？而网上说的volatile只能保证引用的可见性是否正确呢？

　　JUC下的另一个并发工具类CopyOnWriteArrayList，这个也定义了一个对象数组 private transient volatile Object[] array; ，但是在访问元素时，并没有特殊的手段保证可见性，在设置元素时，先获取锁，将原数组拷贝一份，修改新数组后，修改array指向新数组。

4. 引申

　　其实这个问题，是之前写一个小功能遇到的，原问题是：线程1需要在线程2和线程3执行完成之后执行，实现方式有很多，比如栅栏、Jdk8的CompletableFuture、同步机制等，还想到一个数组形式，比如一个长度为2的数组，每个线程执行完毕之后，修改对应位置标志，这样避免了同步的问题。我们抛开上面的问题不谈，假设使用volatile修饰数组，实现这个功能，是否没有其他问题呢？

　　其实还有一个缓存行伪共享的问题。见参考资料2，其实就是说不同线程修改同一个缓存行的问题，每个线程读取一个缓存行，修改之后，同步到主存，会导致其他线程中相同的缓存行失效，这将带来性能上的问题。

 

参考：

volatile修饰数组,那么数组元素可见吗?

伪共享(False Sharing)