关于volatile:Java中不可或缺的关键字volatile

volatile 是 Java 中用于润饰变量的关键字，其能够保障该变量的可见性以及程序性，然而无奈保障原子性。更精确地说是 volatile 关键字只能保障单操作的原子性，比方 x =1，然而无奈保障复合操作的原子性，比方 x ++

其为 Java 提供了一种轻量级的同步机制：保障被 volatile 润饰的共享变量对所有线程总是可见的，也就是当一个线程批改了一个被 volatile 润饰共享变量的值，新值总是能够被其余线程立刻得悉。相比于 synchronized 关键字（synchronized 通常称为重量级锁），volatile 更轻量级，开销低，因为它不会引起线程上下文的切换和调度。

可见性：是指当多个线程拜访同一个变量时，一个线程批改了这个变量的值，其余线程可能立刻看到批改的值。咱们一起来看一个例子：

public class VisibilityTest {
    private boolean flag = true;

    public void change() {
        flag = false;
        System.out.println(Thread.currentThread().getName() + "，已批改 flag=false");
    }

    public void load() {System.out.println(Thread.currentThread().getName() + "，开始执行.....");
        int i = 0;
        while (flag) {i++;}
        System.out.println(Thread.currentThread().getName() + ", 完结循环");
    }

    public static void main(String[] args) throws InterruptedException {VisibilityTest test = new VisibilityTest();

        // 线程 threadA 模仿数据加载场景
        Thread threadA = new Thread(() -> test.load(), "threadA");
        threadA.start();

        // 让 threadA 执行一会儿
        Thread.sleep(1000);
        // 线程 threadB 批改 共享变量 flag
        Thread threadB = new Thread(() -> test.change(), "threadB");
        threadB.start();

    }
}

其中：threadA 负责循环，threadB 负责批改共享变量 flag，如果 flag=false 时，threadA 会完结循环，然而下面的例子会死循环！起因是 threadA 无奈立刻读取到共享变量 flag 批改后的值。咱们只需 private volatile boolean flag = true;，加上 volatile 关键字 threadA 就能够立刻退出循环了。

其中 Java 中的 volatile 关键字提供了一个性能：那就是被 volatile 润饰的变量 P 被批改后，JMM 会把该线程本地内存中的这个变量 P，立刻强制刷新到主内存中去，导致其余线程中的 volatile 变量 P 缓存有效，也就是说其余线程应用 volatile 变量 P 在时，都是从主内存刷新的最新数据。而一般变量的值在线程间传递的时候个别是通过主内存以共享内存的形式实现的；

因而，能够应用 volatile 来保障多线程操作时变量的可见性。除了 volatile，Java 中的 synchronized 和 final 两个关键字以及各种 Lock 也能够实现可见性。加锁的话，当一个线程进入 synchronized 代码块后，线程获取到锁，会清空本地内存，而后从主内存中拷贝共享变量的最新值到本地内存作为正本，执行代码，又将批改后的正本值刷新到主内存中，最初线程开释锁。

有序性，顾名思义即程序执行的程序依照代码的先后顺序执行。但古代的计算机中 CPU 中为了可能让指令的执行尽可能地同时运行起来，提醒计算机性能，采纳了 指令流水线。一个 CPU 指令的执行过程能够分成 4 个阶段：取指、译码、执行、写回。这 4 个阶段别离由 4 个独立物理执行单元来实现。

现实的状况是：指令之间无依赖，能够使流水线的并行度最大化然而如果两条指令的前后存在依赖关系，比方数据依赖，管制依赖等，此时后一条语句就必须等到前一条指令实现后，能力开始。所以 CPU 为了进步流水线的运行效率，对无依赖的前后指令做适当的乱序和调度，即古代的计算机中 CPU 是 乱序执行 指令的

另一方面，只有不会改变程序的运行后果，Java 编译器是能够通过 指令重排来 优化性能。然而，重排可能会影响本地处理器缓存与主内存交互的形式，可能导致在多线程的状况下产生 ” 轻微 ” 的 BUG。

指令重排 个别能够分为如下三种类型：

编译器优化重排序，编译器在不扭转单线程程序语义的前提下，能够重新安排语句的执行程序。
指令级并行重排序，古代处理器采纳了指令级并行技术来将多条指令重叠执行。如果不存在数据依赖性，处理器能够扭转语句对应机器指令的执行程序。
内存零碎重排序，因为处理器应用缓存和读 / 写缓冲区，这使得加载和存储操作看上去可能是在乱序执行。这并不是显式的将指令进行重排序，只是因为缓存的起因，让指令的执行看起来像乱序。

从 Java 源代码到最终执行的指令序列，个别会经验上面三种重排序：

编译器优化重排序 – 指令级并行重排序 – 内存零碎重排序 – 最终执行的指令排序

咱们一起来看一个例子，让大家体悟 volatile 关键字的禁止指令重排的作用：

int i = 0;
int j = 0;
int k = 0;
i = 10; 
j = 1;

对于下面的代码咱们失常的执行流程是：

初始化 i 初始化 j 初始化 k i 赋值 j 赋值

但因为指令重排序问题，代码的执行程序未必就是编写代码时候的程序。语句可能的执行程序如下：

初始化 i i 赋值初始化 j j 赋值初始化 k

指令重排对于非原子性的操作，在不影响最终后果的状况下，其拆分成的原子操作可能会被重新排列执行程序, 晋升性能。指令重排不会影响单线程的执行后果，然而会影响多线程并发执行的后果正确性。

但当咱们用 volatile 润饰变量 k 时：

int i = 0;
int j = 0;
volatile int k = 0;
i = 10; 
j = 1;

这样会保障下面代码执行程序：变量 i 和 j 的初始化，在 volatile int k = 0 之前，变量 i 和 j 的赋值操作在 volatile int k = 0 前面

咱们能够应用 volatile 关键字去阻止重排 volatile 变量四周的读写指令，这种操作通常称为 memory barrier（内存屏障）

volatile 关键字除了禁止指令重排的作用，还有一个个性：当线程向一个 volatile 变量写入时，在线程写入之前的其余所有变量（包含非 volatile 变量）也会刷新到主内存。当线程读取一个 volatile 变量时，它也会读取其余所有变量（包含非 volatile 变量）与 volatile 变量一起刷新到主内存。只管这是一个重要的个性，然而咱们不应该过于依赖这个个性，来 ” 主动 ” 使四周的变量变得 volatile，若是咱们想让一个变量是 volatile 的，咱们编写程序的时候须要十分明确地用 volatile 关键字来润饰。

volatile 关键字无奈保障原子性，更精确地说是 volatile 关键字只能保障单操作的原子性，比方 x =1，然而无奈保障复合操作的原子性，比方 x ++

所谓原子性：即一个或者多个操作作为一个整体，要么全副执行，要么都不执行，并且操作在执行过程中不会被线程调度机制打断；而且这种操作一旦开始，就始终运行到完结，两头不会有任何上下文切换（context switch）

int  = 0;   // 语句 1，单操作, 原子性的操作

i++;         // 语句 2，复合操作，非原子性的操作

其中：语句 2i++ 其实在 Java 中执行过程，能够分为 3 步：

1.i 被从局部变量表（内存）取出，
2. 压入操作栈（寄存器），操作栈中自增
3. 应用栈顶值更新局部变量表（寄存器更新写入内存）

执行上述 3 个步骤的时候是能够进行线程切换的，或者说是能够被另其余线程的这 3 步打断的，因而语句 2 不是一个原子性操作

咱们再来看一个例子：

public class Test1 {

    public static volatile int val;

    public static void add() {for (int i = 0; i < 1000; i++) {val++;}
    }

    public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(Test1::add);
        Thread t2 = new Thread(Test1::add);
        t1.start();
        t2.start();
        t1.join();// 期待该线程终止
        t2.join();
        System.out.println(val);
    }
}

2 个线程各循环 2000 次，每次 +1，如果 volatile 关键字可能保障原子性，预期的后果是 2000，但理论后果却是：1127，而且屡次执行的后果都不一样，能够发现 volatile 关键字无奈保障原子性。

咱们能够利用 synchronized 关键字来解决下面的问题：

public class SynchronizedTest {
    public static int val;

    public synchronized static void add() {for (int i = 0; i < 1000; i++) {val++;}
    }

    public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(SynchronizedTest::add);
        Thread t2 = new Thread(SynchronizedTest::add);
        t1.start();
        t2.start();
        t1.join();// 期待该线程终止
        t2.join();
        System.out.println(val);
    }
}

运行后果：2000

咱们还能够通过加锁来解决上述问题：

public class LockTest {

    public static int val;

    static Lock lock = new ReentrantLock();

    public static void add() {

        for (int i = 0; i < 1000; i++) {

            lock.lock();// 上锁
            try {val++;}catch(Exception e) {e.printStackTrace();
            }finally {lock.unlock();// 解锁
            }

        }

    }

    public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(LockTest::add);
        Thread t2 = new Thread(LockTest::add);
        t1.start();
        t2.start();
        t1.join();// 期待该线程终止
        t2.join();
        System.out.println(val);
    }

}

运行后果：2000

Java 从 JDK 1.5 开始提供了 java.util.concurrent.atomic 包（以下简称 Atomic 包），这个包中的原子操作类, 靠 CAS 循环的形式来保障其原子性，是一种用法简略、性能高效、线程平安地更新一个变量的形式。

这些类能够保障多线程环境下，当某个线程在执行 atomic 的办法时，不会被其余线程打断，而别的线程就像自旋锁一样，始终等到该办法执行实现，才由 JVM 从期待队列中抉择一个线程执行。

咱们来用 atomic 包来解决 volatile 原子性的问题：

public class AtomicTest {public static AtomicInteger val = new AtomicInteger();

    public static void add() {for (int i = 0; i < 1000; i++) {val.getAndIncrement();
        }
    }

    public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(AtomicTest::add);
        Thread t2 = new Thread(AtomicTest::add);
        t1.start();
        t2.start();
        t1.join();// 期待该线程终止
        t2.join();
        System.out.println(val);
    }
}

运行后果：2000, 如果咱们保护现有的我的项目，如果遇到 volatile 变量最好将其替换为 Atomic 变量, 除非你真的特地理解 volatile。Atomic 就不开展说了，先挖个坑，当前补上

当大家认真读完上文的懒汉式单例 — 双重校验锁 volatile 版，会发现 volatile 关键字润饰变量后，咱们反汇编后会发现多出了 lock 前缀指令，lock 前缀指令在汇编中 LOCK 指令前缀性能如下：

被润饰的汇编指令成为 ” 原子的 ”

与被润饰的汇编指令一起提供 ” 内存屏障 ” 成果（lock 指令可不是内存屏障）

内存屏障次要分类：

1. 一类是能够强制读取主内存，强制刷新主内存的内存屏障，叫做 Load 屏障和 Store 屏障

2. 另一类是禁止指令重排序的内存屏障，次要有四个别离叫做 LoadLoad 屏障、StoreStore 屏障、LoadStore 屏障、StoreLoad 屏障

这 4 个屏障具体作用：

LoadLoad 屏障：（指令 Load1; LoadLoad; Load2），在 Load2 及后续读取操作要读取的数据被拜访前，保障 Load1 要读取的数据被读取结束。
LoadStore 屏障：（指令 Load1; LoadStore; Store2），在 Store2 及后续写入操作被刷出前，保障 Load1 要读取的数据被读取结束。
StoreStore 屏障：（指令 Store1; StoreStore; Store2），在 Store2 及后续写入操作执行前，保障 Store1 的写入操作对其它处理器可见。
StoreLoad 屏障：（指令 Store1; StoreLoad; Load2），在 Load2 及后续所有读取操作执行前，保障 Store1 的写入对所有处理器可见。它的开销是四种屏障中最大的。在大多数处理器的实现中，这个屏障是个万能屏障，兼具其它三种内存屏障的性能

对于 volatile 操作而言，其操作步骤如下：

每个 volatile 写入之前，插入一个 StoreStore，写入当前插入一个 StoreLoad
每个 volatile 读取之前，插入一个 LoadLoad，读取之后插入一个 LoadStore

咱们再总结以下，用 volatile 关键字润饰变量后，次要产生的变动有哪些？：

1. 当一个线程批改了 volatile 润饰的变量，当批改后的变量写回主内存时，其余线程能立刻看到最新值。即 volatile 关键字保障了并发的可见性

应用 volatile 关键字润饰共享变量后，每个线程要操作该变量时会从主内存中将变量拷贝到本地内存作为正本，但当线程操作完变量正本，会强制将批改的值立刻写入主内存中。而后通过 CPU 总线嗅探机制告知其余线程中该变量正本全副生效，（在 CPU 层，一个处理器的缓存回写到内存会导致其余处理器的缓存行有效），若其余线程须要该变量，必须从新从主内存中读取。

2. 在 x86 的架构中，volatile 关键字底层含有 lock 前缀的指令，与被润饰的汇编指令一起提供 ” 内存屏障 ” 成果，禁止了指令重排序，保障了并发的有序性

确保一些特定操作执行的程序, 让 cpu 必须依照程序执行指令，即当指令重排序时不会把其前面的指令排到内存屏障之前的地位，也不会把后面的指令排到内存屏障的前面；即在执行到内存屏障这句指令时，在它后面的操作曾经全副实现；

3.volatile 关键字无奈保障原子性，更精确地说是 volatile 关键字只能保障单操作的原子性，比方 x =1，然而无奈保障复合操作的原子性，比方 x ++。

有人可能问赋值操作是原子操作，原本就是原子性的，用 volatile 润饰有什么意义？在 Java 数据类型足够大的状况下（在 Java 中 long 和 double 类型都是 64 位），写入变量的过程分两步进行，就会产生 Word tearing（字决裂）状况。JVM 被容许将 64 位数量的读写作为两个独自的 32 位操作执行，这减少了在读写过程中产生上下文切换的可能性，多线程的状况下可能会呈现值会被毁坏的状况

在不足任何其余爱护的状况下，用 volatile 修饰符定义一个 long 或 double 变量，可阻止字决裂状况

关于volatile:Java中不可或缺的关键字volatile

什么是 volatile 关键字

保障可见性

保障有序性

变量初始化赋值

懒汉式单例 — 双重校验锁 volatile 版

暗藏个性

无奈保障原子性

volatile 版

synchronized 版

Lock 版

Atomic 版 i++

volatile 原理

Just My Socks（注册教程内含优惠码）

关于volatile:Java中不可或缺的关键字volatile

什么是 volatile 关键字

保障可见性

保障有序性

变量初始化赋值

懒汉式单例 — 双重校验锁 volatile 版

暗藏个性

无奈保障原子性

volatile 版

synchronized 版

Lock 版

Atomic 版 i++

volatile 原理

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）