大家好，又见面了，我是你们的朋友全栈君。

前言：

要真正搞懂volatile的特性需要与JMM对比来看

JMM（线程安全的保证）

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

JMM关于同步的规定

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

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

如图所示 可以说cache缓存 就是 这种JMM内存模型的硬件抽象

JMM的特性：可见性，原子性，有序性。

说回到volatile

volatile

volatile 是java虚拟机提供的轻量级同步机制
导致并发问题的源头是 : 多核 CPU 缓存导致程序的可见性问题、多线程间切换带来的原子性问题以及编译优化带来的顺序性问题。

下面是三个volatile特性

可见性

用代码证明volatile的可见性

class MyDate { 
   
    //共享变量 1.1 首先不加volatile关键字
    int number = 0;

    public void change() { 
   
        this.number = 60;
    }
}

/** * 1.验证volatile的可见性 */
public class VolatileDemo { 
   
    public static void main(String[] args) { 
   
        MyDate myDate = new MyDate();
        new Thread(() -> { 
   
            System.out.println(Thread.currentThread().getName() + "\t come in");
            try { 
   
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) { 
   
                e.printStackTrace();
            }
            myDate.change();
            System.out.println(Thread.currentThread().getName() + "\t update number value=" + myDate.number);
        }, "A线程").start();

        //main线程读到的数据
        while (myDate.number == 0) { 
   
            //main 线程一直循环等待直到number值不等于0
        }
        System.out.println(Thread.currentThread().getName() + "\t over number value="+myDate.number);
    }
}

首先new了一个名字叫A线程的线程。先让线程sleep三秒钟，此时A线程和main线程都拿到了number的值。然后A线程修改了number的值为60。但是main线程因为没有可见性不知道值发生了修改。还是继续循环等待，证明了此时线程之间没有可见性。

1.2 证明volatile可见性 ，我们在 int number前面加上volatile关键字

volatile int number = 0;

此时main线程由可见性及时知道了主内存中的number值发生了修改，跳出了循环。

不保证原子性

代码证明不保证原子性

class MyDate { 
   
    volatile int number = 0;
    public void add() { 
   
        number++;
    }
}

//2.1证明原子性
//原子性是指 完整性，不可分割，就是说某个线程执行时不可分割或被插队。
public class VolatileDemo { 
   
    public static void main(String[] args) { 
   
        MyDate myDate = new MyDate();
        for (int i = 0; i < 10; i++) { 
   
            new Thread(() -> { 
   
                for (int j = 0; j < 1000; j++) { 
   
                    myDate.add();
                }
            }, String.valueOf(i)).start();
        }
        // 等待线程计算完成后 由main线程取最终结果 10*1000 = 1万
        while (Thread.activeCount()>2){ 
    //mian线程和GC后台线程
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+"\t sum value="+myDate.number);
    }

代码for出10个线程，每个线程做1000次add操作。正常来说10个线程操作完成之后number应该等于10000

但是程序没次运行都会得到不同的结果，而且小于10000.
是由于number++这个操作在java中是线程不安全的。

n++这个操作在字节码中分为了三个步骤

getfield —- 拿到原始的值n
iadd ——– 进行+1操作
putfield —–把累加后的值写回

当在多线程环境中，如果多个线程都拿到了原始的n，运算完成后在写回数值之前线程被挂起或阻塞，线程恢复后来不及收到可见性通知就向主内存写下了数值，就会发生写覆盖的情况，丢失数据。

导致了在本程序中无法达到10000.

如何解决呢

public synchronized void add() { 
   
        number++;
    }

首先可能想到的就是synchronized同步方法，但是synchronized太重了，一个方法里面就一个++操作如果用synchronized就好比杀鸡用牛刀，大炮打蚊子。需要功能和性能的同时考虑。

使用java.util.concurrent.atomic下的AtomicInteger类

原子性的增加1 相当于++操作

或者getAndAdd(int delta) 参数填1

 //2.3 原子性int
    AtomicInteger atomicInteger = new AtomicInteger();
    // 原子性方法
    public void addWithAtomic(){ 
   
        atomicInteger.getAndIncrement();
    }

至于为什么AtomicInteger能保证原子性，后面有机会继续详解。

禁止指令重排

指令重排：计算机在执行程序时，为了提高性能，编译器和处理器常常会对指令重排，一般分为编译器优化重排，指令并行的重排，内存系统的重排。

在多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程使用的共享变量的一致性时无法保证的。所以结果无法预测。

int a = 0;
    boolean flag = false;

    public void writer() { 
   
        a = 1;         //语句1
        flag = true;   //语句2
    }

    public void reader() { 
   
        if (flag) { 
        //语句3
            a = a + 1;  //语句4
            System.out.println("value:" + a);
        }
    }

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

实现：在对volatile变量进行写操作时，会在写操作后面加入一条Memory Barriier（内存屏障）告诉内存和CPU，禁止在内存屏障前后的执行指令重排优化

写

读

volatile 使用场景

DCL（双重检查锁）+ volatile的单例模式

public class Singleton { 
   
    private static Singleton instance = null;
    // + volatile ?
    private Singleton() { 
   
        System.out.println(Thread.currentThread().getName() + "\t Singleton的构造方法");
    }

    //DCL Double check lock
    public static Singleton getInstance() { 
   
        if (instance == null) { 
   
            synchronized (Singleton.class) { 
   
                if (instance == null) { 
   
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

如果不加volatile

由于

instance = new Singleton();

要分为3步骤执行

1.分配对象内存空间
2.初始化对象
3.完成对象的引用

步骤2和步骤3不存在数据依赖关系，所以可能发生重排序，1->3->2 此时的引用对象可能还没有完成初始化

当一条线程访问instance不为null时，由于instance实例还没有初始化完成，就造成了线程安全问题。