volatile用法

并发：多个线程访问同一份资源。

并行：一边听歌一边写论文就是并行，同时作事。

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();
        }
    }
}

运行结果以下：