Volatile

Volatile

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

具有三个特征：

1. 保证了可见性
2. 不保证原子性
3. 禁止指令重排序（保证了有序性）

JMM（Java内存模型）：一个抽象的概念，并不是真实存在的，它描述的是一组规范或规则，通过这组规范定义了程序中各个变量的访问方式。JMM规定了主内存和工作内存两种（和JVM的内存划分不是同一个层次上面的），从底层上来讲：主内存对应的是硬件的物理内存，工作内存对应的是寄存器和高速缓存(cache)。

JMM关于同步的规定：

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

JVM运行程序的实体是线程，每个线程在创建的时候，JVM都会为其创建一个工作内存（栈空间），工作内存是每个线程的私有数据区域，而JMM中规定所有的变量都存储在主内存，主内存是共享内存区域，所有线程都可以访问。

线程对变量的操作（读写）必须在工作内存中进行：

1. 首先要将变量从主内存拷贝到自己的工作内存空间
2. 然后对变量进行操作，操作完成后再将变量写回主内存

注：线程不能直接操作内存中变量，各个线程的工作内存空间存储着主内存中变量的拷贝副本，不同的线程无法访问对方的工作内存线程间的传值（通信）必须通过主内存来完成。

JMM线程安全的保证：

1. 可见性
2. 原子性
3. 有序性

可见性：每个线程都有自己的工作内存，所以当某个线程修改完某个变量之后，其他的线程，未必能观察到该变量已经被修改。可见性就是让其他线程在第一时间内知道主内存中的值被修改了。

class Data{
    volatile int number = 0;
    public void add(){
        this.number = 10;
    }
}

/**
 * 验证volatile的可见性
 * 1.没加volatile，main线程不知道修改了number，也就没有可见性，就一直执行while
 * 2.加了volatile，main线程就知道修改了number，也就有了可见性，就会立马跳过while
 */
public class Volatile {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(()->{
            System.out.println(Thread.currentThread().getName() + "  come in ");
            try{
                Thread.sleep(3000);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
            data.add();
            System.out.println(Thread.currentThread().getName() + " add number ");
        },"A").start();
        
        while(data.number==0){ } //如果没有volatile，那么main线程就不会知道number修改了
        System.out.println(Thread.currentThread().getName() + "  " + data.number);
        
    }
    
}

原子性：不可分割，完整性，也即某个线程做某个具体业务时，中间不可被加塞或分割，需要整体完整性，要么同时成功，要么同时失败。

class Data{
    volatile int number = 0;
    public void add(){
        this.number = 10;
    }
    public void addPlus(){
        number++;
    }
}

/**
 * 验证volatile不保证原子性
 * 20个线程都执行了1000次number++，如果时原子性，那么最终的结果应该是20000
 */
public class Volatile {
    public static void main(String[] args) {
        Data data = new Data();
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for(int j = 1;j <= 1000;j++){
                    data.addPlus();
                }
            },String.valueOf(i)).start();
        }
        //需要等待上面线程都执行完了，再用main线程获取值
        while(Thread.activeCount()>2){
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+" number:"+ data.number);
    }
}

为什么volatile不保证原子性？

number++分为了3个过程：

1. 将number从主内存拷贝到线程自己的工作内存

2. 在自己的工作内存中对number进行一次+1的操作

3. 将number的值写回主内存

多个线程同时读取值+1，但是线程可能在写回主内存的时候被加塞，从而导致多个线程写回的值有重复

如何做到保证原子性？

1. 加synchronized，但是没有必要，性能不行
2. 采用JUC原子类

class Data{
    //普通的int的number
    volatile int number = 0;
    public void add(){
        this.number = 10;
    }
    public void addPlus(){
        number++;
    }
	//原子的Integer类
    AtomicInteger atomicInteger = new AtomicInteger();
    public void addAtomic(){
        //原子方法+1
        atomicInteger.getAndIncrement();
    }
}

/**
 * 1.验证volatile的可见性
 * 2.验证volatile不保证原子性
 */
public class Volatile {
    public static void main(String[] args) {
        Data data = new Data();
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for(int j = 1;j <= 1000;j++){
                    data.addPlus();
                    data.addAtomic();
                }
            },String.valueOf(i)).start();
        }
        //需要等待上面线程都执行完了，再用main线程获取值
        while(Thread.activeCount()>2){
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+" finally number : "+ data.number);
        System.out.println(Thread.currentThread().getName()+" finally atomicInteger : "+ data.atomicInteger);
    }
}

有序性

计算机在执行程序时，为了提高性能，编译器和处理器常常会对指令做重排，分为三种：

单线程环境里面确保程序最终执行结果和代码顺序的结果保持一致。

处理器在进行重排序时必须考虑到指令之间的数据依赖性

多线程环境中线程交替执行，由于编译器优化重排的存在，多个线程使用的变量能否保持一致性是无法确定的结果

volatile实现了禁止指令重排优化，从而避免多线程环境下程序出现乱序执行的现象

volatile的实际使用

单例模式：双重锁检查

new 一个对象可以分为3个步骤：

1. 分配内存地址空间
2. 初始化对象
3. 设置对象指向刚才分配的内存地址

第2步和第3步不存在数据依赖性，所以可能发生指令重排序

当没有volatile的时候，由于存在指令重排序，可能出现某一个线程访问instance不为null时，instance的初始化还没有完成，也就出现了线程安全问题。

class Singleton{

    private static volatile Singleton instance = null;

    private Singleton(){
        System.out.println("-----构造方法-----");
    }

    public Singleton getInstance(){

        if(instance == null){
            synchronized(Singleton.class){
                if(instance == null){
                    instance = new Singleton();
                }
            }

        }
        return instance;
    }

}