并发，是多个线程去访问同一个资源；并行，各种事情同时在做。
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。
