JUC（一）：volatile关键字

volatile是什么

​ volatile是java虚拟机提供的轻量级同步机制，它包含三种特性：

• 保证可见性：只要主内存中变量做出修改，其余线程马上会感知到变量的修改。

package com.chinda.java.audition;

import java.util.concurrent.TimeUnit;

class MyData {
    volatile int number = 0;
    public void addTo60 (){
        this.number = 60;
    }
}

/**
 * 0. 先不添加volatile关键字, 执行是否会阻塞; 之后加上volatile关键字, 最后打印会不会执行。
 * 1.验证volatile可见性
 *  1.1 假如int number = 0; number变量没有添加volatile关键词修饰没有可见性
 *  1.2 添加volatile，可以解决可见性问题。
 *
 * @author Wang Chinda
 * @date 2020/5/2
 * @see
 * @since 1.0
 */
public class VolatileDemo {
    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.addTo60();
            System.out.println(Thread.currentThread().getName() + "\t update number value: " + myData.number);
        }, "T1").start();

        while (myData.number == 0) {
            // 主线程跳出此循环, 说明线程时可见, 若阻塞在此循环, 说明线程不可见。
        }
        System.out.println(Thread.currentThread().getName() + "\t mission is over! numer value: " + myData.number);
    }
}

• 不保证原子性：

package com.chinda.java.audition;

import java.util.concurrent.atomic.AtomicInteger;

class MyData1 {
    volatile int number = 0;
    AtomicInteger atomic = new AtomicInteger();

    public void addPlus() {
        this.number++;
    }

    public void addAtomic() {
        atomic.getAndIncrement();
    }

}

/**
 * 1.验证volatile不保证原子性
 *  1.1 原子性: 即某个线程正在做某个具体业务, 中间不可以被加塞或者被分割。需要整体完整，要么同时成功，要么同时失败。
 *  1.2 一个线程将属性值写回主内存,没有来得及通知其他线程时, 有其他线程也要将属性值写回主内存, 属性值在主内存中出现覆盖现象。所以volatile不保证原子性。
 * 2. 解决非原子性问题。
 *  2.1 添加synchronized
 *  2.2 添加锁lock
 *  2.3 用原子类AtomicInteger
 *
 * @author Wang Chinda
 * @date 2020/5/2
 * @see
 * @since 1.0
 */
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 = 0; 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 finally! numer value: " + myData.number);
        System.out.println(Thread.currentThread().getName() + "\t finally! atomic value: " + myData.atomic.get());
    }
}

• 禁止指令重排

JMM概念

​ JMM本身是一种抽象的概念，并不真实存在，它描述的是一组规则或规范，通过这组规范定义了程序中各个变量(实例字段、静态字段、构成数组对象的元素)的访问方式。包含三种特性：

• 可见性
• 原子性
• 有序性

JMM同步规定

1. 线程解锁前，必须把共享变量的值刷回主内存。

2. 线程加锁前，必须读取主内存内最新值到线程的工作内存中。

3. 加锁与解锁是同一把锁。

   由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存，工作内存时内阁线程私有数据区域，而Java内存模型中规定所有变量都存储在主内存，主内存时共享内存区域，所有线程都可以访问，但线程对变量的操作必须在工作内存中进行，首先要将变量从主内存拷贝到自己的工作内存空间，然后对变量进行操作，操作完成将变量写回主内存。

无volatile修饰JMM

  

无volatile修饰时，主内存中属性修改，各线程中是不可见的。各个线程中工作内存只以运算前在主内存中拷贝的属性值为准。

volatile修饰JMM

  

有volatile修饰时，主内存中的属性修改，各个线程中是可见的，其中一个线程将工作内存中的属性写回主内存中会通知各个线程去同步主内存中的属性值。但是若在通知之前已经将工作内存中的属性修改，再收到通知同步，这时候就会出现属性值覆盖情况。例如上图中，你品，你细品。即volatile可保证线程间的可见性，但是不保证线程中数据的原子性。

单例模式双端检锁线程安全

DCL(双端检锁)机制不一定线程安全，原因是指令重排序的存在，加入volatile可以禁止指令指令重排。

package com.chinda.java.audition;

/**
 * @author Wang Chinda
 * @date 2020-02-16 21:27
 * @see
 * @since 1.0
 */
public class Singleton5 {
    private static volatile Singleton5 INSTANCE;

    private Singleton5() {
        System.out.println("线程: " + Thread.currentThread().getName() + " --> 此行代码被执行多次, 说明线程不安全！！！");
    }

    public static Singleton5 getInstance() throws InterruptedException {

        // 为提升效率
        if (INSTANCE == null) {
            // 类锁, 线程每次都会抢锁
            synchronized (Singleton5.class) {
                if (INSTANCE == null) {
                    Thread.sleep(100);
                    INSTANCE = new Singleton5();
                }
            }
        }
        return INSTANCE;
    }

    public static void main(String[] args)  {
        for (int i = 1; i <= 20000; i++) {
            new Thread(() -> {
                try {
                    Singleton5.getInstance();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }, String.valueOf(i)).start();
        }
    }
}

原因在于某一个线程执行到第一次检测，读取到INSTANCE不为null时，INSTANCE的引用对象可能没有完成初始化。

INSTANCE = new Singleton5();可以分为一下三步完成。

1. memory = allocate(); 1. 分配对象内存空间。
2. INSTANCE -> memory ; 2. 初始化对象。
3. INSTANCE = ; 3. 设置INSTANCE指向刚分配的内存地址，此时INSTANCE != null。

步骤2和步骤3不存在数据依赖关系，而且无论重排前还是重排后程序的执行结果再单线程中并没有变化，因此这种重排优化时允许的。

1. memory = allocate(); 1. 分配对象内存空间。
2. INSTANCE = ; 3. 设置INSTANCE指向刚分配的内存地址，此时INSTANCE != null，但对象还没有初始化完成。
3. INSTANCE -> memory ; 2. 初始化对象。

指令重排只会保证串行语义执行的一致性(单线程)，但是并不会关心多线程间的语义一致性。所有当一个线程访问INSTANCE不为null时，由于INSTANCE实例未必已经初始化完成，也就造成了线程安全问题。