1
// 类加载的触发条件
2
public class ClassLoadingTrigger {
3
    // 1. new 关键字
4
    Object obj = new Object();
5

6
    // 2. 反射调用
7
    // Class.forName("com.example.MyClass")
8

9
    // 3. 子类初始化触发父类初始化
10
    // class Child extends Parent {}
11

12
    // 4. 虚拟机启动时的主类（含 main 方法）
13

14
    // 5. MethodHandle/VarHandle 的使用
15
}

1
// 准备阶段
2
public static int value = 123;
3
// 准备后 value = 0（零值），初始化阶段才变为 123
4

5
public static final int CONSTANT = 123;
6
// 准备后 CONSTANT = 123（final 常量在编译期就确定了）

1
符号引用 -> 直接引用
2

3
com/example/MyClass -> 内存地址 0x7f3a4b2c

1
public class InitOrder {
2
    static {
3
        System.out.println("1");  // <clinit> 中第一行
4
    }
5

6
    private static int value = getValue();
7

8
    static {
9
        System.out.println("3");  // <clinit> 中第三行
10
    }
11

12
    private static int getValue() {
13
        System.out.println("2");
14
        return 42;
15
    }
16

17
    // 输出顺序: 1 -> 2 -> 3
18
}

1
// 线程上下文类加载器（SPI 机制）
2
// 参考: https://github.com/openjdk/jdk/blob/master/src/java.base/share/classes/java/util/ServiceLoader.java
3
ServiceLoader<Driver> drivers = ServiceLoader.load(Driver.class);
4

5
// ServiceLoader 使用线程上下文类加载器
6
public static <S> ServiceLoader<S> load(Class<S> service) {
7
    ClassLoader cl = Thread.currentThread().getContextClassLoader();
8
    return new ServiceLoader<>(service, cl);
9
}

1
传统双亲委派（树状）:
2
Bootstrap -> Extension -> Application
3

4
OSGi（网状）:
5
Bundle A <-> Bundle B <-> Bundle C
6
    ^           ^           ^
7
    +-----------+-----------+

1
+--------------------------------------------------+
2
|                  JVM 运行时数据区                  |
3
+--------------------------------------------------+
4
|  线程共享                                         |
5
|  +--------------------+  +---------------------+  |
6
|  |   方法区 (Metaspace) |  |       堆 (Heap)     |  |
7
|  | - 类元数据          |  | - 新生代             |  |
8
|  | - 常量池            |  |   - Eden            |  |
9
|  | - 静态变量          |  |   - Survivor 0      |  |
10
|  | - JIT 代码缓存      |  |   - Survivor 1      |  |
11
|  +--------------------+  | - 老年代             |  |
12
|                          +---------------------+  |
13
+--------------------------------------------------+
14
|  线程私有                                         |
15
|  +--------------+  +-----------+  +------------+  |
16
|  | 虚拟机栈      |  | 本地方法栈 |  | 程序计数器 |  |
17
|  | - 栈帧        |  | - Native  |  | - 字节码   |  |
18
|  |   - 局部变量表 |  |   方法调用 |  |   行号     |  |
19
|  |   - 操作数栈   |  |           |  |            |  |
20
|  |   - 动态链接   |  |           |  |            |  |
21
|  |   - 返回地址   |  |           |  |            |  |
22
|  +--------------+  +-----------+  +------------+  |
23
+--------------------------------------------------+

1
// 栈帧示例
2
public int add(int a, int b) {
3
    int c = a + b;
4
    return c;
5
}
6

7
// 对应字节码（局部变量表和操作数栈的交互）
8
// 0: iload_1    // 将局部变量表 slot 1 (a) 压入操作数栈
9
// 1: iload_2    // 将局部变量表 slot 2 (b) 压入操作数栈
10
// 2: iadd       // 弹出两个值相加，结果压栈
11
// 3: istore_3   // 弹出结果存入局部变量表 slot 3 (c)
12
// 4: iload_3    // 加载 c
13
// 5: ireturn    // 返回

1
# JDK 8+ 元空间相关参数
2
-XX:MetaspaceSize=256m         # 初始元空间大小
3
-XX:MaxMetaspaceSize=512m      # 最大元空间大小
4
-XX:MinMetaspaceFreeRatio=40   # GC 后最小空闲比例

1
// 源码
2
int a = 1;
3
int b = 2;
4
int c = a + b;
5

6
// 字节码
7
// 0: iconst_1      // 将常量 1 压入操作数栈
8
// 1: istore_1      // 存入局部变量 a
9
// 2: iconst_2      // 将常量 2 压入操作数栈
10
// 3: istore_2      // 存入局部变量 b
11
// 4: iload_1       // 加载 a
12
// 5: iload_2       // 加载 b
13
// 6: iadd          // 加法
14
// 7: istore_3      // 存入局部变量 c

1
# JIT 编译相关参数
2
-XX:CompileThreshold=10000          # 方法调用阈值（C2）
3
-XX:CompileThresholdScaling=1.0     # 阈值缩放因子
4
-Xbatch                             # 同步编译（阻塞等待）
5
-XX:+PrintCompilation               # 打印 JIT 编译日志

1
// 优化前
2
int result = add(a, b);
3

4
public int add(int x, int y) {
5
    return x + y;
6
}
7

8
// JIT 内联后（等价于直接计算）
9
int result = a + b;

1
# 查看内联情况
2
-XX:+PrintInlining

1
public void process() {
2
    // 对象不会逃逸出方法，可以在栈上分配
3
    // 不需要 GC 回收
4
    Point p = new Point(1, 2);
5
    int sum = p.x + p.y;
6
}

1
// 逃逸分析发现 Point 不逃逸
2
// 标量替换后，不创建对象
3
int x = 1;
4
int y = 2;
5
int sum = x + y;

1
// 循环展开（Loop Unrolling）
2
// 优化前
3
for (int i = 0; i < 1000; i++) {
4
    sum += array[i];
5
}
6

7
// 优化后（减少循环开销）
8
for (int i = 0; i < 1000; i += 4) {
9
    sum += array[i];
10
    sum += array[i+1];
11
    sum += array[i+2];
12
    sum += array[i+3];
13
}

1
对象 A <- 引用计数 = 2
2
    ^         ^
3
  ref1      ref2
4

5
循环引用问题:
6
A <-> B  两者引用计数都不为 0，但实际已无法访问

1
标记前:  [A][B][空][C][D][空][E][空][F]
2
标记后:  [A][B][空][X C][X D][空][E][空][F]
3
清除后:  [A][B][空][空][空][空][E][空][F]
4
                                    ^ 内存碎片

1
回收前:
2
Eden:    [A][B][C][D][E][F]
3
S0:      [空]
4
S1:      [G][H]
5

6
存活对象复制到 S1:
7
S1:      [A][B][C][D][E][F][G][H]
8
Eden:    [空]（全部清空）
9
S0:      [空]
10

11
交换 S0 和 S1 的角色

1
标记前:  [A][空][B][空][C][空][D]
2
整理后:  [A][B][C][D][空][空][空]
3
         ^ 无碎片，但移动对象开销大

1
+------+------+------+------+------+------+
2
| E    | S    | O    | E    | H    | E    |
3
+------+------+------+------+------+------+
4
| O    | E    | E    | O    | E    | S    |
5
+------+------+------+------+------+------+
6

7
E = Eden Region
8
S = Survivor Region
9
O = Old Region
10
H = Humongous Region（大对象）

1
# 启用 ZGC
2
java -XX:+UseZGC -Xmx4g -jar app.jar
3

4
# ZGC 关键参数
5
-XX:ZCollectionInterval=0    # GC 间隔（0 为不限制）
6
-XX:ZAllocationSpikeTolerance=2  # 分配峰值容忍度
7
-XX:+UnlockDiagnosticVMOptions -XX:+ZStatisticsForceTrace  # 统计追踪

1
着色指针（Colored Pointer）:
2
+------+------+------+------+------+------+
3
| 固定位 | finalizable | remap | marked1 | marked0 |
4
+------+------+------+------+------+------+
5
                    ^
6
            通过指针上的标记位判断对象状态
7

8
读屏障（Load Barrier）:
9
对象引用加载时检查指针颜色
10
如果颜色不对，通过转发表找到新地址
11
整个过程与应用线程并发执行

1
// volatile 写操作的字节码层面
2
// 会插入内存屏障指令
3

4
// 写操作前: StoreStore 屏障
5
// 写操作后: StoreLoad 屏障
6

7
// 读操作前: 无屏障
8
// 读操作后: LoadLoad 屏障 + LoadStore 屏障

1
// 单例模式中的 double-check locking
2
public class Singleton {
3
    private volatile static Singleton instance;
4

5
    public static Singleton getInstance() {
6
        if (instance == null) {               // 第一次检查
7
            synchronized (Singleton.class) {
8
                if (instance == null) {        // 第二次检查
9
                    instance = new Singleton(); // volatile 防止指令重排序
10
                }
11
            }
12
        }
13
        return instance;
14
    }
15
}
16

17
// 没有 volatile 可能的问题:
18
// instance = new Singleton() 实际分三步:
19
// 1. 分配内存空间
20
// 2. 初始化对象
21
// 3. 将引用指向内存地址
22
// 重排序后可能变成 1->3->2，导致其他线程拿到未初始化的对象

1
// synchronized 在字节码层面使用 monitorenter/monitorexit
2
public void syncMethod() {
3
    synchronized (this) {
4
        // monitorenter
5
        // 临界区代码
6
        // monitorexit
7
    }
8
}

1
# 堆大小设置
2
-Xms2g                          # 初始堆大小
3
-Xmx4g                          # 最大堆大小（建议与 Xms 相同）
4
-Xmn1g                          # 新生代大小
5
-Xss512k                        # 线程栈大小
6

7
# GC 选择
8
-XX:+UseG1GC                    # 使用 G1
9
-XX:+UseZGC                     # 使用 ZGC（JDK 11+）
10
-XX:+UseShenandoahGC            # 使用 Shenandoah（JDK 12+）
11

12
# GC 日志（JDK 9+ 统一日志格式）
13
-Xlog:gc*:file=gc.log:time,uptime,level,tags
14

15
# 元空间
16
-XX:MetaspaceSize=256m
17
-XX:MaxMetaspaceSize=512m
18

19
# JIT 相关
20
-XX:ReservedCodeCacheSize=256m  # JIT 代码缓存大小

1
# 1. 生成堆转储
2
jmap -dump:format=b,file=heap.hprof <pid>
3

4
# 或使用 JVM 参数自动在 OOM 时生成
5
-XX:+HeapDumpOnOutOfMemoryError
6
-XX:HeapDumpPath=/tmp/heap.hprof
7

8
# 2. 查看堆中对象统计
9
jmap -histo <pid> | head -20
10

11
# 3. 查看 GC 状况
12
jstat -gcutil <pid> 1000 10  # 每秒打印一次，共 10 次
13

14
# 输出示例:
15
#  S0     S1     E      O      M     CCS    YGC   YGCT   FGC  FGCT
16
#  0.00  45.23  67.89  72.34  95.12  91.56   156  2.345    3  0.892

1
# 启用 GC 日志（JDK 8）
2
-XX:+PrintGCDetails
3
-XX:+PrintGCDateStamps
4
-Xloggc:/tmp/gc.log
5

6
# 启用 GC 日志（JDK 9+）
7
-Xlog:gc*:file=gc.log:time,level,tags
8

9
# 使用 GCEasy 分析: https://gceasy.io/
10
# 使用 GCViewer 分析: https://github.com/chewiebug/GCViewer

1
[GC pause (G1 Evacuation Pause) (young), 0.0234567 secs]
2
   [Eden: 256.0M(256.0M)->0.0B(230.0M)
3
    Survivors: 0.0B->26.0M
4
    Heap: 256.0M(512.0M)->24.0M(512.0M)]
5
 [Times: user=0.08 sys=0.01, real=0.02 secs]