面试必备笔记：深入理解 JVM

public class User {
private int age = -1;
private String name = "unknown";
}

// java -jar ~/Downloads/jol-cli-latest.jar internals -cp . com.jol.User
OFF  SZ               TYPE DESCRIPTION               VALUE
0   8                    (object header: mark)     0x0000000000000001 (non-biasable; age: 0)
8   4                    (object header: class)    0xf8021e85 // User.class 引用地址
 12   4                int User.age                  -1         // 基本类型则直接存储值
 16   4   java.lang.String User.name                 (object)   // 引用类型，指向运行时常量池中的 String 对象
 20   4                    (object alignment gap)               // 有 4 字节的内存填充
Instance size: 24 bytes

// -Xms20m -Xmx20m -XX:+HeapDumpOnOutOfMemoryError
public class HeapOOM {
 static class OOMObject {}
 public static void main(String[] args) {
  List<OOMObject> vs = new ArrayList<>();
  while (true)
     vs.add(new OOMObject());
 }
}

String s1 = "java"; // 类加载时，从字节码常量池中拷贝符号到了运行时常量池，在解析阶段初始化的字符串对象
String s2 = "j";
String s3 = s2 + "ava"; // 堆上动态分配的字符串对象
println(s3 == s1);          // false
println(s3.intern() == s1); // true // 已在字符串常量池中存在

assign(var, obj):
incr_ref(obj) # self = self # 先增再减，避免引用自身导致内存提前释放
decr_ref(var)
var = obj
 
incr(obj):
obj.rc++

decr(obj):
obj.rc--
if obj.rc == 0:
  remove_ref(obj) # 断开 obj 与其他对象的引用关系
  gc(obj)         # 回收 obj 内存

public static void main(String[] args) {
// softRefList --> SoftReference --> 10MB byte[] 
List<SoftReference<byte[]>> softRefList = new ArrayList<>();
ReferenceQueue<byte[]> softRefQueue = new ReferenceQueue<>(); // 无效引用队列
for (int i = 0; i < 5; i++) {
  SoftReference<byte[]> softRef = new SoftReference<>(new byte[10*1024*1024], softRefQueue);
  softRefList.add(softRef);

  for (SoftReference<byte[]> ref : softRefList) // dump 所有软引用指向的对象，检查是否已被回收
      System.out.print(ref.get() == null ? "gced " : "ok ");
  System.out.println();
}
Reference<? extends byte[]> ref = softRefQueue.poll();
while (ref != null) {
  softRefList.remove(ref); // 解除对软引用对象本身的引用
  ref = softRefQueue.poll();
}
System.out.println("effective soft ref: " + softRefList.size()); // 2
}

// java -verbose:gc -XX:NewSize=30m -Xms50m -Xmx50m -XX:+PrintGCDetails com.ch02.DemoRef
ok 
ok ok 
// 分配第三个 []byte 时，Eden GC 无效，触发 Full GC 将一个 []byte 晋升到老年区
// 此时三个 byte[] 都只被软引用所引用，被标记为待二次回收（若为弱引用，此时 Eden 已被回收）
[GC (Allocation Failure) --[PSYoungGen: 21893K->21893K(27136K)] 21893K->32141K(47616K), 0.0046324 secs]
[Full GC (Ergonomics) [PSYoungGen: 21893K->10527K(27136K)] [ParOldGen: 10248K->10240K(20480K)] 32141K->20767K(47616K), [Metaspace: 2784K->2784K(1056768K)], 0.004 secs]
ok ok ok
// 再次 GC，前三个 byte[] 全部被回收
[GC (Allocation Failure) --[PSYoungGen: 20767K->20767K(27136K)] 31007K->31007K(47616K), 0.0007963 secs]
[Full GC (Ergonomics) [PSYoungGen: 20767K->20759K(27136K)] [ParOldGen: 10240K->10240K(20480K)] 31007K->30999K(47616K), [Metaspace: 2784K->2784K(1056768K)], 0.003 secs]
[GC (Allocation Failure) --[PSYoungGen: 20759K->20759K(27136K)] 30999K->30999K(47616K), 0.0007111 secs]
[Full GC (Allocation Failure) [PSYoungGen: 20759K->0K(27136K)] [ParOldGen: 10240K->267K(20480K)] 30999K->267K(47616K), [Metaspace: 2784K->2784K(1056768K)], 0.003 secs]
gced gced gced ok
gced gced gced ok ok

void oop_field_store(oop* field, oop new_val) { // oop: ordinary object pointer
// pre_write_barrier(field, new_val); // 写前屏障：更新前先执行，使用 oop 旧状态
*field = new_val;
post_write_barrier(field, new_val); // 写后屏障：更新完才执行
}

byte[] buf1 = new byte[6 * MB];
byte[] buf2 = new byte[6 * MB]; // 10MB 的 eden 区剩余 4MB，空间不足，触发 minor GC

// java -verbose:gc -Xms20m -Xmx20m -Xmn10m -XX:+PrintGCDetails -XX:+UseSerialGC com.ch03.Allocation
// minor gc 后新生代内存从 6M 降到 0.2M，存活对象移到了老年区，总的堆内存用量依旧是 6MB
[GC (Allocation Failure) [DefNew: 6823K->286K(9216K), 0.002 secs] 6823K->6430K(19456K), 0.002 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
Heap
 def new generation   total 9216K, used 6513K 
eden space 8192K,  76% used // buf2
from space 1024K,  28% used
to   space 1024K,   0% used 
 tenured generation   total 10240K, used 6144K
 the space 10240K,  60% used // buf1

byte[] buf1 = new byte[4 * MB];

// java -verbose:gc -Xms20m -Xmx20m -Xmn10m -XX:+PrintGCDetails -XX:+UseSerialGC
// -XX:PretenureSizeThreshold=3145728 com.ch03.Allocation // 3145728 即 3MB
Heap
 def new generation   total 9216K, used 843K 
eden space 8192K,  10% used 
from space 1024K,   0% used 
to   space 1024K,   0% used 
 tenured generation   total 10240K, used 4096K 
 the space 10240K,  40% used // buf1

byte[] buf1 = new byte[MB / 16];
byte[] buf2 = new byte[4 * MB];
byte[] buf3 = new byte[4 * MB]; // 触发 minor gc
buf3 = null;
buf3 = new byte[4 * MB];

// java -verbose:gc -Xms20m -Xmx20m -Xmn10m -XX:+PrintGCDetails -XX:+UseSerialGC 
// -XX:MaxTenuringThreshold=1 -XX:+PrintTenuringDistribution com.ch03.Allocation
[GC (Allocation Failure) [DefNew
Desired survivor size 524288 bytes, new threshold 1 (max 1)
- age   1:     359280 bytes,     359280 total
: 4839K->350K(9216K)] 4839K->4446K(19456K), 0.0017247 secs] 
// 至此，buf1 熬过了第一次收集，age=1
[GC (Allocation Failure) [DefNew
Desired survivor size 524288 bytes, new threshold 1 (max 1): 4446K->0K(9216K)] 8542K->4438K(19456K)] 
Heap
 def new generation   total 9216K, used 4178K 
eden space 8192K,  51% used 
from space 1024K,   0% used // buf1 在第二轮收集中被提前晋升
to   space 1024K,   0% used 
 tenured generation   total 10240K, used 4438K 
 the space 10240K,  43% used 

ClassFile {
u4             magic;         // 魔数
u2             minor_version; // 版本号
u2             major_version;
u2             constant_pool_count; // 常量池
cp_info        constant_pool[constant_pool_count-1];
u2             access_flags;     // 类访问标记
u2             this_class;       // 本类全限定名
u2             super_class;      // 单一父类
u2             interfaces_count; // 多个接口
u2             interfaces[interfaces_count];
u2             fields_count;  // 字段表
field_info     fields[fields_count];
u2             methods_count; // 方法表
method_info    methods[methods_count];
u2             attributes_count; // 类属性
attribute_info attributes[attributes_count];
}

CONSTANT_Utf8_info {
  u1 tag;           // 值为 1
  u2 length;        // bytes 数组长度，u2 最大值 65535，即单个字符串字面量不超过 64KB
  u1 bytes[length]; // 长度不定的字节数组
}

CONSTANT_Class_info {
  u1 tag;        // 值为 7
  u2 name_index; // 指向全限定类名的 Utf8_info // 常量间存在层级组合关系
}

CONSTANT_Fieldref_info {
  u1 tag;                 // 值为 9
  u2 class_index;         // 所属类
  u2 name_and_type_index; // 字段的名称、类型描述符
}
CONSTANT_Methodref_info {
  u1 tag;                 // 值为 10
  u2 class_index;         // 所属类
  u2 name_and_type_index; // 方法的名称、签名描述符
}
CONSTANT_NameAndType_info {
  u1 tag;              // 值为 12
  u2 name_index;       // 字段或方法的名称
  u2 descriptor_index; // 类型描述符
}

field_info {
u2             access_flags;     // 作用域、static,final,volatile 等访问标记
u2             name_index;       // 字段名
u2             descriptor_index; // 类型描述符
u2             attributes_count; // 字段的属性表
attribute_info attributes[attributes_count];
}

method_info {
u2             access_flags;     // 访问标记
u2             name_index;       // 方法名
u2             descriptor_index; // 方法描述符
u2             attributes_count; // 方法属性表
attribute_info attributes[attributes_count];
}

attribute_info {
u2 attribute_name_index;   // 属性名
u4 attribute_length;       // 属性数据长度
u1 info[attribute_length]; // 其他字段，各属性的结构不同
}

Code_attribute {
  u2 attribute_name_index; // 属性名，指向的 Utf8_info 值固定为 "Code"
  u4 attribute_length;     // 剩下字节长度
  u2 max_stack;  // 操作数栈最大深度，对于此方法的栈帧中操作数栈的深度
  u2 max_locals; // 以 slot 变量槽为单位的局部变量表大小，存储隐藏参数 this，实参列表，catch 参数，局部变量等
  u4 code_length;       // 字节码指令总长度
  u1 code[code_length]; // JVM 指令集大小 200+，单个指令的编号用 u1 描述
  u2 exception_table_length; // 异常表，描述方法内各指令区间产生的异常及其 handler 地址
  {   u2 start_pc;   // catch_type 类型的异常，会在 [start_pc, end_pc) 指令范围内抛出
      u2 end_pc;   
      u2 handler_pc; // 若抛出此异常，则 goto 到 handler_pc 处执行
      u2 catch_type;
  } exception_table[exception_table_length];
  u2 attributes_count; // Code 属性自己的属性
  attribute_info attributes[attributes_count];
}

LineNumberTable_attribute {
  u2 attribute_name_index; u4 attribute_length;
  u2 line_number_table_length;
  {   u2 start_pc;     // 字节码指令区间开始位置
      u2 line_number;  // 对应的源码行号
  } line_number_table[line_number_table_length];
}

LocalVariableTable_attribute {
  u2 attribute_name_index; u4 attribute_length;
  u2 local_variable_table_length;
  {   u2 start_pc; // 局部变量生命周期开始的字节码偏移量
      u2 length;   // 向后生命周期覆盖的字节码长度
      u2 name_index;       // 变量名
      u2 descriptor_index; // 类型描述符
      u2 index; // 对应的局部变量表中的 slot 索引
  } local_variable_table[local_variable_table_length];
}

package com.cls;

public class Structure {
public static void main(String[] args) {
  System.out.println("hello world");
}
}

cafe babe # 1.  u4 魔数，标识 class 文件类型
0000 0034 # 2.  u2,u2 版本号，52 JDK8 

# 3. 常量池
---1---
001f # u2 constant_pool_count，31 项（从 1 开始计数，0 预留）
0a      # u1 tag，10，Methoddef_info，成员方法结构 
0006    # u2 index，6，所属类的 Class_info 在常量池中的编号   ## java/lang/Object
0011    # u2 index，17，此方法 NameAndType 编号             ## <init>:()V

---2---
09      # 9，Fileddef_info，成员变量结构
0012    # u2 index，18，所属类 Class_info 编号     ## java/lang/System
0013    # u2 index，19，此字段 NameAndType 编号    ## out:Ljava/io/PrintStream

---3---
08      # 8，String_info，字符串
0014    # u2 index，20，字面量编号     ## hello world

---4---
0a 
0015    # 21    ## java/io/PrintStream
0016    # 22    ## println:(Ljava/lang/String;)V

---5---
07      # Class_info，全限定类名
0017    # u2 index，23，字面量编号     ## com/cls/Structure

---6---
07      # 7，Class_info，类引用
0018    # 24    ## java/lang/Object

---7---
01      # Utf8_info，UTF8 编码的字符串
0006    # u2 length，6，字符串长度
3c 69 6e 69 74 3e # 字面量值    ## "<init>"

---8-16---
01 0003 282956                                          ## "()V"
01 0004 436f6465                                        ## "Code"
01 000f 4c696e654e756d6265725461626c65                  ## "LineNumberTable"
01 0004 6d61696e                                        ## "main"
01 0016 285b4c6a6176612f6c616e672f537472696e673b2956    ## "([Ljava/lang/String;)V"
01 0010 4d6574686f64506172616d6574657273                ## "MethodParameters"
01 0004 61726773                                        ## "args"
01 000a 536f7572636546696c65                            ## "SourceFile"
01 000e 5374727563747572652e6a617661                    ## "Structure.java"

---17---
0c      # 12，NameAndType，名字及类型描述符
0007    # u2 index，7，字段或方法名字面量编号    ## <init>
0008    # u2 index，8，字段或方法结构编号       ## ()V

---18---
07 0019 # 25    ## java/lang/System

---19---
0c
001a 001b   # 26:27    ## out:Ljava/io/PrintStream;

---20---
01 000b 68656c6c6f20776f726c64    ## "hello world"

---21--
07 001c # 28    ## java/io/PrintStream

---22--
0c
001d 001e   # 29:30                             ## println:(Ljava/lang/String;)V

---23-31---
01 0011 636f6d2f636c732f537472756374757265          ## "com/cls/Structure"
01 0010 6a6176612f6c616e672f4f626a656374            ## "java/lang/Object "
01 0010 6a6176 612f 6c61 6e67 2f53 7973 7465 6d     ## "java/lang/System"
01 0003 6f7574                                      ## "out"
01 0015 4c6a6176612f696f2f5072696e7453747265616d3b  ## "Ljava/io/PrintStream;"
01 0013 6a6176612f696f2f5072696e7453747265616d      ## "java/io/PrintStream"
01 0007 7072696e746c6e                              ## "println"
01 0015 284c6a6176612f6c616e672f537472696e673b2956  ## "(Ljava/lang/String;)V"

0021 # 4. u2，access_flags                           ## ACC_PUBLIC | ACC_SUPER
0005 # 5. u2, this_class,5                           ## --5.Class_info--> com/cls/Structure
0006 # 6. u2, super_class, 6                         ## --6.Class_info--> java/lang/Object 
0000 # 7. u2, interface_count, 0
0000 # 8. u2, fields_count, 0

0002 # 9. methods count, 2
  # 方法一
0001    # u2, access_flags, ACC_PUBLIC                 
0007    # u2, name_index, 7                         ## <init> 
0008    # u2, descriptor_index, 8                   ## ()V                          
0001    # u2, attribute_count, 1                             
0009        # u2, attribute_name_index, 9           ## Code 属性
0000 001d   # u4, attribute_length, 30 
0001        # u2, max_stack, 1                                
0001        # u2, max_locals, 1                            
0000 0005  # u4, code_array_length, 5                        
2a               # u1, aload_0                       ## 将第 0 个 slot 中的变量 this 入栈 
b7   0001        # u1, invokespecial                 ## 执行从 Object 继承的 <init>
b1               # u1, return                        ## 返回 void
0000        # u2, exception_table_length, 0          ## exception table 为空，无异常
0001        # u2, attributes_count, 1                ## Code 属性本身的子属性
000a            # 10                                    ## LineNumberTable 属性
0000 0006       # 6
0001            # u2, line_number_table_length, 1
0000                # u2, start_pc, 0
0003                # u2, line_number, 3
  # 方法二
0009    # access_flags                               ## ACC_PIBLIC | ACC_STATIC
000b    # name_index, 11                             ## main
000c    # descriptor_index, 12                       ## ([Ljava/lang/String;)V
0002    # attribute_count, 2
0009        # attribute_name_index, 9                ## Code
0000 0025  # attribute_length, 37
0002        # max_stack, 2 
0001        # max_locals, 1
0000 0009  # code_array_length, 9
b2   0002       # getstatic, 2                       ## Field: java/lang/System.out:Ljava/io/PrintStream; // 加载静态对象变量
12   03         # ldc, 3                             ## String: "hello world"  // 将常量参数入栈
b6   0004       # invokevirtual, 4                   ## Method: java/io/PrintStream.println:(Ljava/lang/String;)V // 执行方法
b1              # return
0000        # exception_table_length, 0
0001        # attributes_count, 1
000a        # 10                                     ## LineNumberTable
0000 000a   # 10
0002            # line_number_table_length, 2
0000 0005           # 0 -> 5
0008 0006           # 8 -> 6

// 将 slot 0,1,2,3,N 加载到栈顶，T 表示类型简记前缀，可取 i,l,f,d,a
Tload_0, Tload_1, Tload_2, Tload_3, Tload n
// 将栈顶数据写回指定的 slot
Tstore_0, Tstore_1, Tstore_2, Tstore_3, Tstore n
// 将不同范围的常量值加载到栈顶，由于 0~5 常量过于常用，有单独对应的指令，ldc 则加载普通常量
bipush, sipush, Tconst_[0,1,2,3,4,5], aconst_null, ldc

Tadd, Tsub, Tmul, Tdiv, Trem     // 算术运算：加减乘除，取余
Tneg, Tor, Tand, Txor            // 位运算：取反、或、与、异或
dcmpg, dcmpl, fcmpg, fcmpl, lcmp // 比较运算：后缀 g 即 greater, l 即 less than
iinc                             // 局部自增运算，与 iload 搭配使用

i2b // int -> byte
i2c, i2s; l2i, f2i, d2i; d2l, f2l; d2f

new                                      // 创建类实例
newarray, annewarray, multianewarry      // 创建基本类型数组、引用类型数组、多维引用类型数组
getfield, putfield; getstatic, putstatic // 读写类实例字段；读写类静态字段
Taload, Tastore; arraylength             // 读写数组元素；计算数组长度
instanceof; checkcast                    // 校验对象是否为类实例；执行强制转换

pop, pop2       // 弹出栈顶 1，2 元素
dup, dup2; swap // 复制栈顶 1，2 个元素并重新入栈；交换栈顶两个元素

if_<icmpeq,icmpne;icmplt,icmple;icmpgt,icmpge;acmpe,acmpne> // 整型比较，引用相等性判断
if<eq,lt,le,gt,ge,null,nonnull>                             // 搭配其他类型的比较运算指令使用

invokevirtual   // 根据对象的实际类型进行分派，调用对应的方法（比如继承后方法重写） 
invokespecial   // 调用特殊方法，如 <cint>()V, <init>()V 等初始化方法、私有方法、父类方法
invokestatic    // 调用类的静态方法
invokeinterface // 调用接口方法（实现接口的类对象，但被声明为接口类型，调用方法）
invokedynamic   // TODO
Treturn, return // 返回指定类型，返回 void

public class ClassX {
final static int n = 2;          // 常量的值在编译期就已知，准备阶段完成赋值，值存储在 ConstantValue
final static String str = "str"; // 字符串静态常量同理
}

static final java.lang.String str;
descriptor: Ljava/lang/String;
flags: ACC_STATIC, ACC_FINAL
ConstantValue: String str

public class ClassX {
static {
  println("main class ClassX init"); // 1. main() 所在的主类，总是先被初始化
}

public static void main(String[] args) throws Exception {
  // 首次会触发类的初始化
  // SubX b = new SubX();  // new 对象 // 2. new, getsatic, putstatic, invokestatic 指令
  // println(SuperX.a);    // 读写类的 static 变量，或调用 static 方法 
  // println(SubX.c);      // 3. 子类初始化，会触发父类初始化
  // println(SubX.a);      //    子类访问父类的静态变量，只会触发父类初始化
  
  // 不会触发类的初始化
  // println(SubX.b);      // 1. 访问类的静态常量（基本类型、字符串字面量）
  // println(SubX.class);  // 2. 访问类对象
  // println(new SubX[2]); // 3. 创建类的数组
}
}

class SuperX {
static int a = 0;
static {
  println("class SuperX initiated");
}
}

class SubX extends SuperX {
final static double b = 0.1;
static boolean c = false;
static {
  println("class SubX initiated");
}
}

// java/lang/ClassLoader
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
    synchronized (getClassLoadingLock(name)) {
        // 1. 先检查自己的加载器是否已加载此类
        Class<?> c = findLoadedClass(name);
        if (c == null) {
            long t0 = System.nanoTime();
            try {
                if (parent != null) {
                    // 2. 还有上层则委派给上层去加载
                    c = parent.loadClass(name, false);
                } else {
                    // 3. 如果没有上级，则委派给 Bootstrap 加载
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // 类不存在
            }

            if (c == null) {
                // 4. 到自己的 classpath 中查找类，用户自定义 ClassLoader 自定义了查找规则
                long t1 = System.nanoTime();
                c = findClass(name);
            }
        }
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }
}

public static void main(String[] args) {
int a = 1008611;
int b = ++a;
}

public static void main(String[] args) {
  {
      byte[] buf = new byte[10 * 1024 * 1024];
  }
  System.gc();  // buf 还在局部变量表的 slot 0 中，作为 GC Root 无法被回收
  // int v = 0; // 变量 v 重用 slot 0，gc 生效
  // System.gc(); 

public class StaticResolution {
 public static void doFunc() {
  System.out.println("do func...");
 }
 public static void main(String[] args) {
  StaticResolution.doFunc();
 }
}

stack=0, locals=1, args_size=1    // 静态方法的调用版本，在编译时就以常量的形式，存入字节码的参数
0: invokestatic  #5           // Method doFunc:()V
  3: return

public class StaticDispatch {
 static abstract class Human {}
 static class Man extends Human {}
 static class Woman extends Human { }

 public void f(Human human) {System.out.println("f(Human)");}
 public void f(Man man) {System.out.println("f(Man)");}
 public void f(Woman woman) {System.out.println("f(Woman)");}

 public static void main(String[] args) {
  Human man = new Man();     // 静态类型都是 Human
  Human woman = new Woman(); // 实际类型分别为 Man, Woman
  StaticDispatch sd = new StaticDispatch();
  sd.f(man);   // f(Human) // invokevirtual #13 // Method f:(Lcom/ch08/StaticDispatch$Human;)V
  sd.f(woman); // f(Human) // 编译期就已确定重载版本，写入字节码中
 }
}

public class DynamicDispatch {
static abstract class Human {
    protected abstract void f();
}

static class Man extends Human {
    @Override
    protected void f() {
        System.out.println("Man f()");
    }
}

static class Woman extends Human {
    @Override
    protected void f() {
        System.out.println("Woman f()");
    }
}

public static void main(String[] args) {
    Human man = new Man(); // 虽然静态类型都是 Human
    Human woman = new Woman();
    man.f();   // Man f()   // invokevirtual #6 // Method com/ch08/DynamicDispatch$Human.f:()V
    woman.f(); // Woman f() // 虽然字节码指令的参数，都是静态类型方法的符号引用
    man = new Woman();
    man.f(); // Woman f() // 但 invokevirtual 会根据 Receiver 实际类型，在运行时解析到实际类的直接引用
}
}

public class FieldHasNoPolymorphic {
static class Father {
    public int money = 1;
    public Father() {
        money = 2;
        showMoney();
    }
    public void showMoney() { System.out.println("Father, money = " + money); }
}

static class Son extends Father {
    public int money = 3; // 子类字段在类加载的准备阶段被赋零值
    public Son() { // 子类构造器第一行默认隐藏调用 super()
        money = 4;
        showMoney();
    }
    public void showMoney() { System.out.println("Son, money = " + money); }
}

public static void main(String[] args) {
    Father guy = new Son(); 
    System.out.println("guy, money = " + guy.money);
}
}

// Son, money = 0 // Father 类构造器执行，动态分派执行了 Son::showMoney()
// Son, money = 4 // Son 类构造器中访问最新的、自己的 money 字段
// guy, money = 2 // 字段的读写没有动态分派，静态类型是谁，就访问谁的字段