Volatile原理详解

最新推荐文章于 2024-08-15 15:48:28 发布

Munger6

最新推荐文章于 2024-08-15 15:48:28 发布

阅读量356

点赞数

分类专栏：并发编程文章标签： volatile 多线程

本文链接：https://blog.csdn.net/Munger6/article/details/99302285

版权

并发编程专栏收录该内容

19 篇文章 1 订阅

订阅专栏

Volatile，实现有序性和可见性，是实现线程安全的一种重要机制，是java虚拟机提供的最轻量级的同步机制；能保证线程获取该变量的最新值，避免出现数据脏读现象；其中重要实现机制：防止指令重排序 + 变量操作的可见性；

1、Volatile的案例：

实现线程修改数据的可读；

package online.morn.study.math;

import java.util.concurrent.ArrayBlockingQueue;

public class TestMain  extends Thread{

	private static boolean flag = false;

	//private volatile static boolean flag = false;

    /*****
     * 特别注意：
     *    ①System.out.println切记不要使用，因为这里使用了synchronized (this) {} 会进行一次同步
     */
	@Override
	public void run() {
		while (!flag){
//			System.out.println("我还在线程中" + flag);   
		}
//		System.out.println("我跳出了线程" + flag);
	}

	public static void main(String[] args) throws Exception {
		new TestMain().start();
		Thread.sleep(1000);
		flag = true;
//		System.out.println("修改值flag =" + flag);
//		Thread.sleep(2000);
	}
}

2、可见性是什么？

可见性问题是什么首先需要了解清楚可见性问题产生的原因是什么；可参考之前文章并发问题的产生与规避；简要概述就是因为磁盘-缓存-cpu缓存中间存在巨大的执行效率差异，因此在硬件层面增加了cpu告诉缓存提前加载数据，最大化cpu资源，避免cpu等待数据加载；但是在多线程环境下，就存在多个线程的缓存区间之间数据的可见性问题（一个线程进行了操作，另一个线程是否可以读取到最新数据）；

可见性的硬件解决方案：

方案1：总线锁，将并行的变为串行；

缺点：性能下降，无法发挥多线程的高性能优势；

方案2：缓存锁，MESI协议， MESI表达的缓存的四种状态（
   S-shared 数据有效，存在很多cpu缓存、
   E-Exlusive 数据有效，本地缓存独有
   M-Modify修改状态数据有效，但是被修改了，与主内存数据不一致，数只存在本cache中
   I-Invalid这行数据无效）；
   但是其没有解决缓存可见性；
   会缓存间的通信与同步时的阻塞{ 当缓存1在进行write的时候，会给缓存2发送失效(invalidate)信息，
   缺点：在缓存2失效确认ack发送回来之前缓存1都处于阻塞状态}；
   方案3：StoreBuffer 引入解决阻塞等待：当write的时候，将消息发送给 StoreBuffer而不用等待；

同步数据的问题交给StoreBuffer
   缺点：1、还是存在短暂的数据可见性问题
     2、先读取storeBuffer再读主内存的方式，会因为指令重排序的优化造成可见性问题；

总结：cpu无法彻底解决在跨线程之间，程序对象之间的依赖关系问题；因此提供了指令：内存屏障；解决数据可见性和指令重排序问题；

可见性的JMM层面解决方案：通过合理的静止缓存中的重排序实现了可见性和有序性；

JMM本质是规范，没有真正的代码实现；

【JMM规范】：多线程环境抽象为：主内存 -- 多个工作内存 -- 多个线程；
解决方案： volatile synchronized final -不可变的 happens-before；
  实现理论：
编译器JVM级别的内存屏障 ： OrderAccess::loadload() 两个读的屏障 load1一定早于load2
OrderAccess::storeload() 类似全屏障 OrderAccess::loadstore() OrderAccess::storestore()
cpu层面内存屏障 ：loadMemoryBarrier 、 storeMemoryBarrier fullMemoryBarrier ；

JMM内存屏障：LoadLoadBarriers 、 StoreStoreBarriers、 LoadStoreBarriers 、 StoreLoadBarriers
happens-before规则：当 a happens before b 存在这种关系的时候则一定对内存可见；而无需使用 volatile ;
JVM中那些操作会建立happens before规则？
规则1，程序顺序规则，程序中的顺序性不可变；
   1 happens - before 2
   if（a）{ // 1
   b = 4; //2
   }
规则2，volation变量规则，对volation修饰的写一定在读之前；
规则3，传递性规则，如果 1 happens - before 2 并且 2 happens - before 3 一定会 1 happens - before 3
规则4，线程启动规则() 案例：StartRule.java 在satrt()之前的值修改一定对线程内操作可见；
规则5，线程终止规则案例：JoinRule.java 在线程中的操作对thread.join之后的线程可见；
规则6，管程锁定规则（synchronized）案例SynRule.java ThreadA 先拿到锁一定其操作一定对后拿到锁的ThreadB可见；
规则7，线程终止规则对线程interrupt()方法的调用先行发生于被中断线程代码检测到中断事件的发生
规则8，对象终结规则构造函数执行的结束一定 happens-before它的 finalize()方法回收

遵循happens-before的案例：

public class VolatileExample {
    private int a = 0;
    private volatile boolean flag = false;
    public void writer(){
        a = 1;          //1
        flag = true;   //2
    }
    public void reader(){
        if(flag){      //3
            int i = a; //4
        }
    }
}