并发：多个线程访问同一份资源。
并行：一边听歌一边写论文就是并行，同时做事。
volatile是java虚拟机提供的轻量级的同步机制。
voliatile有三大特性：
1.保证可见性。
2.不保证原子性。
3.禁止指令重排。
JMM(Java内存模型 Java Memory Model)本身是一种抽象的概念并不真实存在，它描述的是一组规则或规范，通过这组规范定义了程序中各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式。
JMM关于同步的规定：
1.线程解锁前，必须把共享变量的值刷新回主内存
2.线程加锁前，必须读取主内存的最新值到自己的工作内存。
3.加锁解锁是同一把锁。
由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存（有些地方称为栈空间），工作内存是每个线程的私有数据区域，而Java内存模型中规定所有变量都存储在主内存，主内存是共享内存区域，所有线程都可以访问，但线程对变量的操作（读取赋值等）必须在工作内存中进行，首先要将变量从主内存拷贝到自己的工作内存空间，然后对变量进行操作，操作完成后再将变量写回主内存，不能直接操作主内存中的变量，各个线程中的工作内存中存储主内存的变量副本拷贝，因此不同的线程间无法访问对方的工作内存，线程间的通信（传值）必须通过主内存来完成。
JMM的三大特性：
1.可见性。
2.原子性。
3.有序性。
volatile可见性代码例子：
class MyData {
volatile int number = 0;
public void add() {
this.number =60;
}
}
/**
* 验证volatile的可见性,如果number不用volatile修饰，那么main线程将死循环，因为volatile具有可见性，可以及时通知其他线程主内存的值已经修改
*/
public class VolatileDemo {
public static void main(String[] args) {
MyData myData = new MyData();
new Thread(() ->{
System.out.println(Thread.currentThread().getName()+"\t come in number = " + myData.number);
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
myData.add();
System.out.println(Thread.currentThread().getName()+"\t update number = " + myData.number);
},"t1").start();
while (myData.number == 0) {
}
System.out.println(Thread.currentThread().getName()+"\t 执行完,当前number = " +myData.number);
}
}
运行结果见下图：
验证volatile不保证原子性
原子性指的是什么？
不可分割，完整性，也即某个线程正在做某个具体业务时，中间不可以被加塞或者被分割，需要整体完整要么同时成功，要么同时失败。
例子如下：
class MyData1 {
volatile int number = 0;
public void addPlus() {
/** number++ 底层其实被拆分成了3个指令：
执行getfield拿到元原始number;
执行iadd进行加1操作；
执行putfield写把累加后的值写回
*/
number++;
}
AtomicInteger atomicInteger = new AtomicInteger();
public void addAtomic() {
atomicInteger.getAndIncrement(); //CAS,底层是unsafe类和自旋，保证原子性
}
}
/**
* 验证volatile的原子性
*/
public class VolatileDemo1 {
public static void main(String[] args) {
MyData1 myData = new MyData1();
for(int i = 1; i<=20; i++) {
new Thread(() ->{
for(int j = 1; j<= 1000; j++) {
myData.addPlus();
myData.addAtomic();
}
},String.valueOf(i)).start();
}
//需要等待上面20个线程都全部计算完成后，再用main线程取得最终的结果看是多少
while (Thread.activeCount() > 2) {
Thread.yield();
}
System.out.println(Thread.currentThread().getName()+"\t int number 的最终结果是" +myData.number);
System.out.println(Thread.currentThread().getName()+"\t atomic number 的最终结果是" +myData.atomicInteger);
}
}
运行结果见下图：
原因分析：例如有3个线程同时写操作，主内存值是0，3个线程分别拷贝自己工作内存后值0都进行了加1，有可能线程1刚把值1写入了主内存，线程2或线程3由于某些原因挂起现在突然被唤醒，由于时间太快还没收到最新值的通知又去写成1，等于写覆盖丢失了数据，正常主内存的值是3，结果3个线程操作写覆盖结果变成1。可以使用JUC下面的AtomicInteger解决原子性i++问题。
volatile指令重排
计算机再执行程序时，为了提高性能，编译器和处理器的常常会对指令做重排，一般分为以下3种
源代码→编译器优化的重排→指令并行的重排→内存系统的重排→最终执行的指令
单线程环境里面确保程序最终执行结果和代码顺序执行的结果一致。
处理器在进行重排序时必须要考虑指令之间的数据依赖性。
多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测。
例子：
public class ReSortDemo {
int a = 0;
boolean flag = false;
public void method1() {
a = 1;
flag = true;
}
/**
* 多线程环境中线程交替执行，由于编译器优化重排的存在
* 两个线程中使用的变量能否保证一致性无法确定， 变量a 和变量 flag 由于不存在依赖性，多线程下指令重排可能先执行flag,
* 而变量a 还是旧值0，打印结果就可能是5而不是6
*/
public void method2() {
if(flag) {
a = a+5;
System.out.println(a);
}
}
}
单例模式volatile例子：
public class SingletonDemo {
private static volatile SingletonDemo instance = null;
private SingletonDemo() {
System.out.println(Thread.currentThread().getName()+"我是构造方法");
}
/** DCL(双层检锁机制)不一定线程安全，原因是有指令重排序的存在，加入volatile可以禁止指令重排
* 原因在于某一个线程执行到第一个检测，读取到的instance不为null时，instance的引用对象可能没有完成初始化
* instance = new SingletonDemo();可以分为以下3步完成（伪代码）
* memory = allocate();//1. 分配对象内存空间
* instance(memory);//2.初始化对象
* instance = memory;//3.设置instance指向刚分配的内存地址，此时instance != null
*步骤2和步骤3不存在数据依赖关系，而且无论重排前还是重排后程序的执行结果在单线程中并没有改变，因此这种重排序
* 是允许的
* 多线程下可能导致的顺序就是132
* @return
*/
public static SingletonDemo getInstance() {
if(instance == null) {
synchronized (SingletonDemo.class) {
if(instance == null) {
instance = new SingletonDemo();
}
}
}
return instance;
}
public static void main(String[] args) {
//模拟10个线程
for (int i = 1; i<= 10; i++) {
new Thread(() ->{
SingletonDemo.getInstance();
},String.valueOf(i)).start();
}
}
}
运行结果如下：
