大橙子网站建设,新征程启航

为企业提供网站建设、域名注册、服务器等服务

如何实现Java并发volatile可见性

小编这次要给大家分享的是如何实现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,但子线程一直不会退出循环,因为子线程一直没有同步到 主内存中的变量的值。

如何实现Java并发volatile可见性

截图可见程序一直没有退出,使用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可见性
链接地址:http://dzwzjz.com/article/jcgjcg.html
在线咨询
服务热线
服务热线:028-86922220
TOP