重学Volatile

并发，是多个线程去访问同一个资源；并行，各种事情同时在做。

volatile是java虚拟机提供的轻量级的同步机制

三大特性，保证可见性，不保证原子性，禁止指令重排序

先说下JMM（java内存模型Java Memory Model）本身是一种抽象的概念并不是真实存在的，它描述的是一组规则或规范，通过这组规范定义了程序中各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式。

JMM关于同步的规定：

• 1、线程解锁前，必须把共享变量的值刷新回主内存；
• 2、线程加锁前，必须读取主内存的最新值到自己的工作内存
• 3、加锁解锁是同一把锁

要求可见性，保证原子性、有序性，但是volatile只能保证两个，所以说volatile是轻量级的同步机制。

由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存（有些地方称为栈空间），工作内存是每个线程的私有数据区域，而Java内存模型中规定所有变量都存储在主内存中，主内存是共享内存区域，所有线程都可以访问，但线程对变量的操作（读取赋值等）必须在工作内存中进行，首先将变量从主内存拷贝到自己的工作内存空间，然后对变量进行操作，操作完成后再将变量写回主内存，不能直接操作主内存中的变量，各个线程中的工作内存中存储着主内存中的变量副本考本，因此不同的线程间无法访问对方的工作内存，线程间的通信（传值）必须通过主内存来完成，如图所示。

 

一、volatile 保证可见性，就是数据都存放在主内存中，各个线程想要修改主内存的数据时，需要把主内存的数据，复制一份到自己的工作内存中，修改数据后，把数据再写回给主内存，其他线程再从主内存中获取最新的数据值。 代码验证

class MyData{
   volatile int number=0;
    public void addNumber(){
        this.number=60;
    }
  }
 
public class voliteDemo{
    public static void main(String args[]){
        MyData myData = new MyData();
        
        new Thread(()->{
        System.out.println(Thread.currentThread().getName()+"\t come in");
        try{
        TimeUnit.SECONDS.sleep(3);  
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        myData.addNumber();
        System.out.println(Thread.currentThread().getName()+"\t update number value" + myData.number);
        
        },"AAA").start();
        
        while(myData.number==0){}
        
        System.out.println(Thread.currentThread().getName()+"\t main thread  vaule "+ myData.number);
         
    }

}
复制代码

总结，线程AAA,和主线程是两个线程。线程AAA，修改了变量的值后，如果不加volatile修饰变量，主线程是不知道变量变更的，如果加了volatile修饰变量，修改变量的值后，主线程是可以知道修改后的变量的值。添加volatile关键字修饰，可以保证可见性。

二、volatile不保证原子性，什么是原子性呢，不可分割，完整性，即某个线程正在处理某个业务的时候，中间不可以被加塞或者被分割，需要整体完整要么同时成功，要么同时失败。

class MyData{
    volatile int number = 0;
   
    public void addPlusPlus(){
        number++;
       
    }
}


class MyDataDemo{
    public static void main(String args[]){
        MyData myData = new MyData();
        for(int i =1;i<=20;i++){
              new Thread(()->{
                  for(j=1;j<=1000;j++){
                  myData.addPlusPlus();
                  }
              },String.valueof(i)).start();
        }
        while(Thread.activeCount() >2){
            Thread.yield();
        }
        
        System.out.println(Thread.currentThread().getName()+"\t number value "+myData.number);
    
    }

}
复制代码

运行之后number的值会小于20000，说明volatile不能保证原子性。多线程访问方法，会出现丢数据的情况。说明下为什么不能保证原子性，因为多个线程去修改主内存中的变量时，都是把主内存的变量复制到自己的工作内存中，每个线程修改完变量后，再回写回主内存。当一个线程修改变量的值后，回写回主内存和其他的线程回写回主内存的值是一样的，所以被覆盖了，就会出现丢数据的情况。 解决保证原子性，可以使用synchronized，但是使用synchronized太重了，不建议使用。可以使用AtomicInterger。修改代码

class MyData{
    volatile int number =0;
    
    AtomicInteger atomicInteger = new AtomicInteger();
    
    public void addAtomic(){
        atomicInteger.getAndIncrement();
    }

}


public class VolatileDemo{

    public static void main(String args[]){
    
    MyData myData = new MyData();
    
    for(inti=0; i<20;i++){
         new Thread(()->{
                  for(j=1;j<=1000;j++){
                  myData.addAtomic();
                  }
              },String.valueof(i)).start();
    
    }
    
  while(Thread.activeCount() >2){
            Thread.yield();
        }
        
        System.out.println(Thread.currentThread().getName()+"\t number value "+myData.atomicInteger);

}

}


复制代码

这个时候就可以保证原子性 为什么加了atomic就可以解决原子性，因为使用了CAS（比较再交换）。

三、volatile，禁止指令重排序。在多线程的情况下，源码写的顺序，编译器写的顺序不一定会一样。单线程的时候，确保程序最终执行结果和代码顺序执行结果的一致性。 源代码->编译器优化的重排->指令并行的重排->内存系统的重排->最终执行的指令。

int a,b,x,y = 0;


线程1           线程2
x=a;            y=b;
b=1;            a=2;
输出x=0 y=0
如果编译器对这个段代码重排优化，
线程1           线程2
b=1；           a=2；
x=a；           y=b；
输出x= 2，y=1；

复制代码

这就编译器修改了执行的顺序，带来的结果不一样。然后使用volatile关键字修饰变量后，编译器就不会再进行重排序。

线程安全性获得保证：

工作内存与主内存同步数据延迟现象导致可见性的问题，可以使用synchronized和volatile关键字解决，它们都可以使一个线程修改后的变量立即对其它线程可见。

对于指令重排序导致的可见性问题，可以使用volatile关键字解决，因为volatile可以禁止指令重排序。

哪些地方用到了volatile：

单例模式,使用双重判断，出现指令重排，使用volatile禁止指令重排。

CAS的源码，JUC的包里大量使用的volatile。