上節回顧：類加載機制

雙親委派機制

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級別是如何規范的。

超強干貨來襲 云風專訪：近40年碼齡，通宵達旦的技術人生

總結

以上是生活随笔為你收集整理的JVM从入门到精通（三）：热加载的实现原理，Java内存模型，缓存行，指令重排，合并写技术等的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。