首页 > 代码库 > 并发编程(二):全视角解析volatile

并发编程(二):全视角解析volatile

一、目录

  1、引入话题-发散思考

  2、volatile深度解析

  3、解决volatile原子性问题

  4、volatile应用场景

二、引入话题-发散思考

public class T1 {     /*volatile*/ boolean running=true;      public void m(){          System.out.println(Thread.currentThread().getName()+":start!");           while(running){                /*try {                     TimeUnit.MINUTES.sleep(2);                } catch (Exception e) {                     e.printStackTrace();                }*/           }          System.out.println(Thread.currentThread().getName()+":end!");     }      public static void main(String[] args) {           T1 t=new T1();            new Thread(()->t.m(),"t").start();           try {                TimeUnit.SECONDS.sleep(1);           } catch (Exception e) {                e.printStackTrace();           }           t.running=false;     }}运行结果:无volatile:t:start! 有volatile:t:start!t:end!
含有volatile是期望的结果,那为什么不添加volatile会产生这种情况呢?
再谈Java内存模型:
技术分享

 

技术分享
     在虚拟机中,堆内存用于存储共享数据(实例对象),堆内存也就是这里说的主内存。
     每个线程将会在堆内存中开辟一块空间叫做线程的工作内存,附带一块缓存区用于存储共享数据副本。那么,共享数据在堆内存当中,线程通信就是通过主内存为中介,线程在本地内存读并且操作完共享变量操作完毕以后,把值写入主内存。
 
解析无volatile:
  • 根据上述java内存模型可知,最开始running=true在主存中,开启线程A,线程会把主存的running=true复制一份写入工作内存的共享变量副本中。
  • 当我们改变running=false,在主存中已经发生改变。
  • 线程A一直在工作状态,没有空闲时间去知道主存的情况,而是一直在读本地内存的共享变量副本,也就一直running=true,取而代之也会产生上述情况。

三、volatile深度解析

那为什么含有volatile就能及时刷新工作内存呢?它有什么作用呢?
volatile:可见性(一个线程修改共享变量以后,立马会被其他线程知可见)、禁止重排序。
 
1、什么是可见性?
虚拟机的happens-before中的volatile规则:volatile变量写操作先于读操作,一个线程去读取volatile变量,另一个线程去写volatile变量,那么volatile变量的写操作优先。
  • 根据上述java内存模型可知,最开始running=true在主存中,开启线程A,线程会把主存的running=true复制一份写入工作内存的共享变量副本中。
  • 当我们改变running=false,在主存已经发生改变。
  • 就在这时,当主存与工作内存发生不一致的时候,工作内存的共享变量会失效,那么工作内存就会去主存刷新一遍共享变量,所以running=false,自然就执行下面的代码啦!

 

2、什么是禁止重排序?
先谈有序性:
int a=1;int b =3;int c=a*b;
在虚拟机中,执行上述代码,一定是按照上述顺序执行吗?那可不一定,像a=1,b=3的顺序完全可能先执行b=3,a=1,这被称为重排序;但是c=a*b一定在a=1,b=3后面,这被成为有序性。
 
再谈重排序:
//线程1:context = loadContext();  //语句1inited = true;            //语句2//线程2:while(!inited ){  sleep()}doSomethingwithconfig(context);
假设上述代码在单线程中,谈过重排序不会对代码造成什么影响,但是我们看这一段代码。
语句1与语句2并没有太多的依赖关系,参考有序性例子,那么他们就可以重排序,那么可能语句2执行先于语句1,假设在线程1中语句2执行完就刷新inited到主存,还没等语句1执行呢?线程2就执行起来,一看inited=true,挑出循环,执行下面的代码,context=null就报出空指针,显然这是不能被虚拟机允许的。
 
所以,volatile明确规定禁止重排序,意思就是context=loadContext必须先于inited执行。
在虚拟机中设定了有序性,也就是前面谈到的happens-before原则。如果不满足上该原则的情况下,虚拟机是可以自由的重排序的,下面附录此规则。
 
3、先行发生原则(happens-before)
    • 程序次序规则:一个线程内,按照代码顺序,书写在前面的操作先行发生于书写在后面的操作
    • 锁定规则:一个unLock操作先行发生于后面对同一个锁的lock操作
    • volatile变量规则:对一个变量的写操作先行发生于后面对这个变量的读操作
    • 传递规则:如果操作A先行发生于操作B,而操作B又先行发生于操作C,则可以得出操作A先行发生于操作C
    • 线程启动规则:Thread对象的start()方法先行发生于此线程的每个一个动作
    • 线程中断规则:对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生
    • 线程终结规则:线程中所有的操作都先行发生于线程的终止检测,我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行
    • 对象终结规则:一个对象的初始化完成先行发生于他的finalize()方法的开始

四、解决volatile原子性问题

1、volatile能解决原子性问题吗?什么是原子性呢,本不想解释,为了读者能够更透彻理解,再解释一下。

原子性:只有一个线程访问共享数据,也就是当线程A访问一个代码块的时候,其他线程全部堵塞,只有等代码块全部执行完,才能被其他线程访问共享数据。
 public class T2 {     volatile int count=0;      public void m(){           for(int i=0;i<1000;i++)                count++;     }      public static void main(String[] args) {           T2 t=new T2();           List<Thread> threads=new ArrayList<Thread>();            for(int i=0;i<10;i++){                threads.add(new Thread(()->t.m(),"thread-"+i));           }            threads.forEach((o)->o.start());            //等待所有线程都执行完           threads.forEach((o)->o.yield());            System.out.println("count:"+t.count);     }}运行结果:count:8710 //每次都不一样。

 

 2、为什么加了volatile还是不能得到预期结果呢?因为它只保证了可见性,不能保证原子性。what?

再回忆java内存模型:

技术分享
 

3、那怎么解决呢?

方式一:synchronized,jvm对synchronized进行了很大的优化,所以效率也没有想象中那么低。

public class T3 {     int count=0;      public synchronized void m(){           for(int i=0;i<1000;i++)                count++;     }      public static void main(String[] args) {           T3 t=new T3();           List<Thread> threads=new ArrayList<Thread>();            for(int i=0;i<10;i++){                threads.add(new Thread(()->t.m(),"thread-"+i));           }            threads.forEach((o)->o.start());            //等待所有线程都执行完           threads.forEach((o)->o.yield());            System.out.println("count:"+t.count);     }}

方式二:ReentrantLock,跟synchronized的作用差不多。

public class T5 {     ReentrantLock lock=new ReentrantLock();     int  count=0;      public void m(){           lock.lock();           for(int i=0;i<1000;i++)                count++;           lock.unlock();     }      public static void main(String[] args) {           T4 t=new T4();           List<Thread> threads=new ArrayList<Thread>();            for(int i=0;i<10;i++){                threads.add(new Thread(()->t.m(),"thread-"+i));           }            threads.forEach((o)->o.start());            //等待所有线程都执行完           threads.forEach((o)->o.yield());            System.out.println("count:"+t.count);     } }
方式三:AtomicInteger原子类
public class T4 {     AtomicInteger count=new AtomicInteger(0);      public void m(){           for(int i=0;i<1000;i++)                count.getAndIncrement();     }      public static void main(String[] args) {           T4 t=new T4();           List<Thread> threads=new ArrayList<Thread>();            for(int i=0;i<10;i++){                threads.add(new Thread(()->t.m(),"thread-"+i));           }            threads.forEach((o)->o.start());            //等待所有线程都执行完           threads.forEach((o)->o.yield());            System.out.println("count:"+t.count);     }}

五、volatile应用场景

说到这里,读者可能就已经懵逼了,这也有问题那也有问题,那我们什么时候用它呢?
volatile是基于synchronized提出的效率优化手段,但是它是不能代替synchronized的。
 
状态标记量:
一般volatile共享变量,不要用于数据计算,最好去标记一些状态值,比如前面说的running=true。
volatile boolean inited = false;//线程1:context = loadContext();inited = true;//线程2:while(!inited ){sleep()}doSomethingwithconfig(context);

 九、版权声明

  作者:邱勇Aaron

  出处:http://www.cnblogs.com/qiuyong/

  您的支持是对博主深入思考总结的最大鼓励。

  本文版权归作者所有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,尊重作者的劳动成果。

  参考:深入理解JVM、马士兵并发编程、并发编程实践

     volatile关键字解析:http://www.importnew.com/18126.html

并发编程(二):全视角解析volatile