Java并发volatile可见性的验证实现

普通读无法及时获得主内存变量

public class volatileTest {
  static boolean flag = false;//非volatile变量

  public static void main(String[] args) throws Exception {
    new Thread(new Runnable() {
      @Override
      public void run() {
        while(!flag){
        };
      }
    }).start();
    Thread.sleep(100);
    flag = true;
    System.out.println("主线程运行完毕");
  }
}

主线程已经修改了flag为true，但子线程一直不会退出循环，因为子线程一直没有同步到主内存中的变量的值。

截图可见程序一直没有退出，使用dump threads后：

"Thread-0" #12 prio=5 os_prio=0 tid=0x0000000022d89800 nid=0x168 runnable [0x00000000248df000]
java.lang.Thread.State: RUNNABLE
at volatileTest$1.run(volatileTest.java:10)
at java.lang.Thread.run(Thread.java:745)

volatile读及时获得主内存变量

public class volatileTest {
  static volatile boolean flag = false;//volatile变量

  public static void main(String[] args) throws Exception {
    new Thread(new Runnable() {
      @Override
      public void run() {
        while(!flag){
        };
      }
    }).start();
    Thread.sleep(100);
    flag = true;
    System.out.println("主线程运行完毕");
  }
}

加了一个volatile关键字，子线程就能检测到flag的变化了。子线程会退出。

普通读+sleep

public class volatileTest {
  static boolean flag = false;//非volatile变量

  public static void main(String[] args) throws Exception {
    new Thread(new Runnable() {
      @Override
      public void run() {
        while(!flag){
          try {
            Thread.sleep(1);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        };
      }
    }).start();
    Thread.sleep(100);
    flag = true;
    System.out.println("主线程运行完毕");
  }
}

加了sleep，子线程会退出。

其实就算变量不是volatile的，JVM也会尽量去保证可见性。最开始的例子，由于CPU一直执行循环，没有其他时间来获取主内存中的变量的最新值，但加了sleep后，CPU就有时间去获取主内存中的东西了。

普通读+同步块

public class volatileTest {
  static boolean flag = false;//非volatile变量
  static Object sync = new Object();

  public static void main(String[] args) throws Exception {
    new Thread(new Runnable() {
      @Override
      public void run() {
        while(!flag){
          synchronized (sync) {}//随便synchronized一个对象
          //synchronized (this)也可以
        };
      }
    }).start();
    Thread.sleep(100);
    flag = true;
    System.out.println("主线程运行完毕");
  }
}

加了同步块，子线程会退出。

这是因为synchronized具体过程是：

获得同步锁；
清空工作内存；
从主内存拷贝对象副本到工作内存；
执行代码(计算或者输出等)；
刷新主内存数据；
释放同步锁。

简单的说，synchronized进入时，会将主内存中最新的变量，拷贝进自己线程的工作内存。synchronized退出时，会把自己线程的工作内存的变量弄进主内存中。

同步块遭遇锁消除

public class volatileTest {
  static boolean flag = false;//非volatile变量

  public static void main(String[] args) throws Exception {
    new Thread(new Runnable() {
      @Override
      public void run() {
        while(!flag){
          synchronized (new Object()){}
        };
      }
    }).start();
    Thread.sleep(100);
    flag = true;
    System.out.println("主线程运行完毕");
  }
}

子线程不会退出。

原因是：synchronized (new Object()){}中这个Object永远不可能逃逸到同步块以外去，所以同步操作其实根本不需要执行了，既然没有执行同步，那么相当于这里是啥也没有。

普通读+System.out.println

public class volatileTest {
  static boolean flag = false;

  public static void main(String[] args) throws Exception {
    new Thread(new Runnable() {
      @Override
      public void run() {
        while(!flag){
          System.out.println("子线程running");
        };
      }
    }).start();
    Thread.sleep(100);
    flag = true;
    System.out.println("主线程运行完毕");
  }
}

加了System.out.println，子线程会退出。

因为out这个PrintStream实例的println实现是：

  public void println(String x) {
    synchronized (this) {
      print(x);
      newLine();
    }
  }

因为它也有同步块。

到此这篇关于Java并发volatile可见性的验证实现的文章就介绍到这了,更多相关Java并发volatile验证内容请搜索呐喊教程以前的文章或继续浏览下面的相关文章希望大家以后多多支持呐喊教程！

声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：notice#nhooo.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。

基础教程