JVM从入门到精通（三）：热加载的实现原理，Java内存模型，缓存行，指令重排，合并写技术等

上节回顾：类加载机制

双亲委派机制

parent只是一个成员变量，不是继承关系。

上节课的遗留问题

parent是怎么指定的？
手动指定parent：

双亲委派机制可以被打破吗？

双亲委派机制是在ClassLoader类里的LoadClass()方法已经写死的，你只需重写FingClass()方法就可以了。那怎么打破它呢？

热加载的实现原理

Tomcat把整个ClassLoader全部干掉，再用自己实现的ClassLoader把新修改过的类的Class重新Load一遍。

正确版本：将一个class加载两次

package com.mashibing.jvm.c2_classloader;import com.mashibing.jvm.Hello;import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;public class T012_ClassReloading2 {private static class MyLoader extends ClassLoader {@Overridepublic Class<?> loadClass(String name) throws ClassNotFoundException {File f = new File("C:/work/ijprojects/JVM/out/production/JVM/" + name.replace(".", "/").concat(".class"));if(!f.exists()) return super.loadClass(name);try {InputStream is = new FileInputStream(f);byte[] b = new byte[is.available()];is.read(b);return defineClass(name, b, 0, b.length);} catch (IOException e) {e.printStackTrace();}return super.loadClass(name);}}public static void main(String[] args) throws Exception {MyLoader m = new MyLoader();Class clazz = m.loadClass("com.mashibing.jvm.Hello");m = new MyLoader();Class clazzNew = m.loadClass("com.mashibing.jvm.Hello");System.out.println(clazz == clazzNew);}
}

无效版本：使用的仍然是加载过的类

package com.mashibing.jvm.c2_classloader;public class T011_ClassReloading1 {public static void main(String[] args) throws Exception {T006_MSBClassLoader msbClassLoader = new T006_MSBClassLoader();Class clazz = msbClassLoader.loadClass("com.mashibing.jvm.Hello");msbClassLoader = null;System.out.println(clazz.hashCode());msbClassLoader = null;msbClassLoader = new T006_MSBClassLoader();Class clazz1 = msbClassLoader.loadClass("com.mashibing.jvm.Hello");System.out.println(clazz1.hashCode());System.out.println(clazz == clazz1);}
}

Linking

证明默认值的存在
输出结果为2. 如果交换10 11行，输出结果为3

package com.mashibing.jvm.c2_classloader;public class T001_ClassLoadingProcedure {public static void main(String[] args) {System.out.println(T.count);}
}class T {public static T t = new T(); // 执行到这一步时，下一行的count仍然是默认值0，调用构造方法后，count变为1,public static int count = 2; // 执行到这一步时，上一行的count=1被这一行的count=2覆盖private T() {count ++;}
}

New 一个对象的过程

先分配内存
再赋默认值
再赋初始值

面试题：DCL（Double Check Lock）单例要不要加Volitile？
需要。因为有指令重排的问题。
初始化一半的时候，单例已经存在了，处于半初始化的状态。此时另外一个线程来了，直接把半初始化的对象取走了，出现值的问题。

package com.mashibing.jvm.c0_basic;public class C {public static void main(String[] args) {Object o = new Object();}
}

下图4、7可能会发生重排
官网解释：
new: Create new object
dup: 复制操作数堆栈上的顶部值，并将复制的值压入操作数堆栈。
invoke special: 调用实例方法; 对超类、私有和实例初始化方法调用的特殊处理
astore_<n>: 将引用存储到局部变量中。操作数堆栈顶部的objectref的类型必须是returnAddress或reference类型。它从操作数堆栈中弹出，并将处的局部变量的值设置为objectref。

JMM（Java Memory Model）

硬件层的并发优化基础知识

不同层级的速度差别有多大？

产生数据的不一致问题：两个CPU之间的缓存怎么保持一致？
老的CPU，总线锁：效率偏低

新的CPU：各种各样的一致性协议，例如，intel的MESI协议
4种状态的含义：我改过、只有我在用、别人也在读、失效

现在，CPU的数据一致性实现是通过 缓存一致性协议（MESI…）+总线锁 共同实现的。

缓存行 CacheLine

读取缓存以cacheline为基本单位，多数的实现为64kB（64字节，512位）

伪共享：位于同一缓存行的两个不同数据被两个不同CPU锁定，产生相互影响的问题。

示例1：两个线程修改同一个数组中的值。耗时1255

package com.mashibing.juc.c_028_FalseSharing;import java.util.Random;public class T01_CacheLinePadding {private static class T {public volatile long x = 0L;}public static T[] arr = new T[2];static {arr[0] = new T();arr[1] = new T();}public static void main(String[] args) throws Exception {Thread t1 = new Thread(()->{for (long i = 0; i < 1000_0000L; i++) {arr[0].x = i;}});Thread t2 = new Thread(()->{for (long i = 0; i < 1000_0000L; i++) {arr[1].x = i;}});final long start = System.nanoTime();t1.start();t2.start();t1.join();t2.join();System.out.println((System.nanoTime() - start)/100_0000);}
}

示例2：使用7个long类型的数字（7个*8字节=56字节）将缓存行填起来，加上变量x本身占用的空间，使两个T对象恰巧不在统一缓存行。耗时443
通过缓存行对齐后，效率提升了。
开源的disruptor就考虑到了这个问题。

package com.mashibing.juc.c_028_FalseSharing;public class T02_CacheLinePadding {private static class Padding {public volatile long p1, p2, p3, p4, p5, p6, p7;}private static class T extends Padding {public volatile long x = 0L;}public static T[] arr = new T[2];static {arr[0] = new T();arr[1] = new T();}public static void main(String[] args) throws Exception {Thread t1 = new Thread(() -> {for (long i = 0; i < 1000_0000L; i++) {arr[0].x = i;}});Thread t2 = new Thread(() -> {for (long i = 0; i < 1000_0000L; i++) {arr[1].x = i;}});final long start = System.nanoTime();t1.start();t2.start();t1.join();t2.join();System.out.println((System.nanoTime() - start) / 100_0000);}
}

CPU的乱序执行

CPU为了提高效率，会在一条指令执行过程中（比如去内存读数据，慢100倍），去同时执行另一条指令。前提是两条指令没有依赖关系。

合并写技术

写操作也可以合并

只有4个字节，一次填6个的话，要等下一次把剩下的2个填满。如果一次填4个，就正好填满。

package com.mashibing.juc.c_029_WriteCombining;public final class WriteCombining {private static final int ITERATIONS = Integer.MAX_VALUE;private static final int ITEMS = 1 << 24;private static final int MASK = ITEMS - 1;private static final byte[] arrayA = new byte[ITEMS];private static final byte[] arrayB = new byte[ITEMS];private static final byte[] arrayC = new byte[ITEMS];private static final byte[] arrayD = new byte[ITEMS];private static final byte[] arrayE = new byte[ITEMS];private static final byte[] arrayF = new byte[ITEMS];public static void main(final String[] args) {for (int i = 1; i <= 3; i++) {System.out.println(i + " SingleLoop duration (ns) = " + runCaseOne());System.out.println(i + " SplitLoop  duration (ns) = " + runCaseTwo());}}public static long runCaseOne() {long start = System.nanoTime();int i = ITERATIONS;while (--i != 0) {int slot = i & MASK;byte b = (byte) i;  // 1BytearrayA[slot] = b;  // 1BytearrayB[slot] = b;  // 1BytearrayC[slot] = b;  // 1BytearrayD[slot] = b;  // 1BytearrayE[slot] = b;  // 1BytearrayF[slot] = b;  // 1Byte}return System.nanoTime() - start;}public static long runCaseTwo() {  // 一次正好写满一个四字节的 Buffer，比上面的循环效率更高long start = System.nanoTime();int i = ITERATIONS;while (--i != 0) {int slot = i & MASK;byte b = (byte) i; // 1BytearrayA[slot] = b;  // 1BytearrayB[slot] = b;  // 1BytearrayC[slot] = b;  // 1Byte}i = ITERATIONS;while (--i != 0) {int slot = i & MASK;byte b = (byte) i;arrayD[slot] = b;arrayE[slot] = b;arrayF[slot] = b;}return System.nanoTime() - start;}
}

乱序执行的证明

package com.mashibing.jvm.c3_jmm;public class T04_Disorder {private static int x = 0, y = 0;private static int a = 0, b = 0;// private static volatile int x = 0, y = 0;// private static volatile int a = 0, b = 0;public static void main(String[] args) throws InterruptedException {int i = 0;for (; ; ) {i++;x = 0;y = 0;a = 0;b = 0;Thread one = new Thread(new Runnable() {public void run() {//由于线程one先启动，下面这句话让它等一等线程two. 读着可根据自己电脑的实际性能适当调整等待时间.//shortWait(100000);a = 1;x = b;}});Thread other = new Thread(new Runnable() {public void run() {b = 1;y = a;}});one.start();other.start();one.join();other.join();String result = "第" + i + "次 (" + x + "," + y + "）";if (x == 0 && y == 0) {System.err.println(result);break;} else {//System.out.println(result);}}}public static void shortWait(long interval) {long start = System.nanoTime();long end;do {end = System.nanoTime();} while (start + interval >= end);}
}

如何保证特定情况下不乱序？

Volitile
有序性保证：CPU 级别的内存屏障，我们以 intel CPU 为例：

volitile 变量，它的内存的前后都加了屏障，

下节课，我们讲 Volitile 的有序性在硬件级别是如何保证的、在JVM级别是如何规范的。