volatile保证可见性，不保证原子性、禁止指令重排

volatile是Java虚拟机提供的轻量级的同步机制，保证可见性，不保证原子性、禁止指令重排

1.保证可见性

当多个线程访问同一个变量的时候，一个线程修改了这个变量的值，其他线程能够立刻看到修改的值

package com.jian8.juc;

import java.util.concurrent.TimeUnit;

/**
* 1验证volatile的可见性
* 1.1 如果int num = 0，number变量没有添加volatile关键字修饰
* 1.2 添加了volatile，可以解决可见性
*/
public class VolatileDemo {

public static void main(String[] args) {
visibilityByVolatile();//验证volatile的可见性
}

/**
* volatile可以保证可见性，及时通知其他线程，主物理内存的值已经被修改
*/
public static void visibilityByVolatile() {
MyData myData = new MyData();

//第一个线程
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "\t come in");
try {
//线程暂停3s
TimeUnit.SECONDS.sleep(3);
myData.addToSixty();
System.out.println(Thread.currentThread().getName() + "\t update value:" + myData.num);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}, "thread1").start();
//第二个线程是main线程
while (myData.num == 0) {
//如果myData的num一直为零，main线程一直在这里循环
}
System.out.println(Thread.currentThread().getName() + "\t mission is over, num value is " + myData.num);
}
}

class MyData {
// int num = 0;
volatile int num = 0;

public void addToSixty() {
this.num = 60;
}
}

输出结果：

thread1     come in
thread1     update value:60
//线程进入死循环

当我们加上volatile关键字后，volatile int num = 0;输出结果为：
volatile可以保证可见性，及时通知其他线程，主物理内存的值已经被修改

thread1     come in
thread1     update value:60
main     mission is over, num value is 60
//程序没有死循环，结束执行

2.不保证原子性

原子性：不可分割、完整性，即某个线程正在做某个具体业务时，中间不可以被加塞或者分割，需要整体完整，要么同时成功，要么同时失败。
验证示例（变量添加volatile关键字，方法不添加synchronized）：

package com.jian8.juc;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
* 1验证volatile的可见性
* 1.1 如果int num = 0，number变量没有添加volatile关键字修饰
* 1.2 添加了volatile，可以解决可见性
*
* 2.验证volatile不保证原子性
* 2.1 原子性指的是什么
* 不可分割、完整性，即某个线程正在做某个具体业务时，中间不可以被加塞或者被分割，需要整体完整，要么同时成功，要么同时失败
*/
public class VolatileDemo {

public static void main(String[] args) {
// visibilityByVolatile();//验证volatile的可见性
atomicByVolatile();//验证volatile不保证原子性
}
/**
* volatile可以保证可见性，及时通知其他线程，主物理内存的值已经被修改
*/
    //public static void visibilityByVolatile(){}
/**
* volatile不保证原子性
* 以及使用Atomic保证原子性
*/
public static void atomicByVolatile(){
MyData myData = new MyData();
for(int i = 1; i <= 20; i++){
new Thread(() ->{
for(int j = 1; j <= 1000; j++){
myData.addSelf();
myData.atomicAddSelf();
}
},"Thread "+i).start();
}
//等待上面的线程都计算完成后，再用main线程取得最终结果值
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
while (Thread.activeCount()>2){
Thread.yield();
}
System.out.println(Thread.currentThread().getName()+"\t finally num value is "+myData.num);
System.out.println(Thread.currentThread().getName()+"\t finally atomicnum value is "+myData.atomicInteger);
}
}

class MyData {
// int num = 0;
volatile int num = 0;

public void addToSixty() {
this.num = 60;
}

public void addSelf(){
num++;
}
AtomicInteger atomicInteger = new AtomicInteger();
public void atomicAddSelf(){
atomicInteger.getAndIncrement();
}
}

执行三次结果为：

//1.
main     finally num value is 19580    
main     finally atomicnum value is 20000
//2.
main     finally num value is 19999
main     finally atomicnum value is 20000
//3.
main     finally num value is 18375
main     finally atomicnum value is 20000
//num并没有达到20000

number++在多线程下是非线程安全的，可能会出现写覆盖而丢失数据，不使用synchronize是因为杀鸡焉用牛刀

那么如何解决上面的非原子性操作带来的i++写覆盖问题呢？
1.使用sync
2.使用JUC包下的原子类 AtomicInteger
进而又引出了Atomic相关原子类如何保证原子性的？底层原理是什么？
请看我的另一篇关于CAS的介绍

3.禁止指令重排

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

在多线程环境下，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，volatile实现禁止指令重排序，从而避免了多线程环境下程序出现乱序执行的现象。

禁止指令重排的原理：在指令间插入一条内存屏障（Memory Barrier），就可以禁止在内存屏障前后的指令执行重排序优化，这就保证了特定操作的执行顺序。
内存屏障的另一个作用是强制刷出各种CPU的缓存数据，任何CPU上的线程都能读取到这些数据的最新版本。

单例模式在多线程环境下可能会存在安全性问题，使用单例模式的DCL代码来解决。
DCL（Double Check Lock 双端检锁机制）在加锁前和加锁后都进行一次判断。

public class Singleton4 {
    private Singleton4(){
    }
    private volatile  static Singleton4 instance;
    public static Singleton4 getInstance(){
        if (instance == null){
            synchronized (Singleton4.class){
                if (instance == null){
                    instance = new Singleton4();
                }
            }
        }
        return instance;
    }
}