JVM | 基于openJDK源码深度拆解Java虚拟机

        <dependency>
            <groupId>org.openjdk.jol</groupId>
            <artifactId>jol-core</artifactId>
            <version>0.14</version>
        </dependency>

Object obj = new Object();
System.out.println(ClassLayout.parseInstance(obj).toPrintable());

java.lang.Object object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           e5 01 00 f8 (11100101 00000001 00000000 11111000) (-134217243)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

Disconnected from the target VM, address: '127.0.0.1:9689', transport: 'socket'

InstanceKlass* ClassLoader::load_class(Symbol* name, bool search_append_only, TRAPS) {
	//...省略
	// 检查类是否需要进行字节码验证。
	stream->set_verify(ClassLoaderExt::should_verify(classpath_index));
	// 创建一个空的ClassLoaderData
	ClassLoaderData* loader_data = ClassLoaderData::the_null_class_loader_data();
	// 代码安全相关
	Handle protection_domain;
	// 准备类加载信息
	ClassLoadInfo cl_info(protection_domain);
	// 从流中创建对象，返回InstanceKlass示例类引用
	InstanceKlass* result = KlassFactory::create_from_stream(stream,
                                                           name,
                                                           loader_data,
                                                           cl_info,
                                                           CHECK_NULL);
	result->set_classpath_index(classpath_index);
	// 返回类示例
	return result;
}

  // 类加载器关联的元空间
  ClassLoaderMetaspace * volatile _metaspace;
  // 类加载的对象句柄，持有管理Java对象
  OopHandle  _class_loader;
  Klass*  _class_loader_klass;
  Symbol* _name;
  // 提供一个可以用于遍历所有类加载器的结构，看来底层是使用链表来组织
  void set_next(ClassLoaderData* next);
  ClassLoaderData* next() const;

//类的元数据
metaData
// 常量方法，进一步解读就是不可变的方法，里面包含一些字节码等等结构。
constMethod
// 常量池缓存，可以说是常量池的进阶版了，或者说是运行时常量池。
cpCache
// 记录类型的组件
recordComponent
// 符号，一种特殊的字符串类型，用来记录一些名称，后面会讲到
symbol
// 和CDS有关，这里就不讨论了。
filemap
// 注解相关的东西
annotations
// 数组类
array

class Klass : public Metadata {
 protected:
  // 超类指针，非常关键；用于确认继承，具体调用哪个版本的类，类型检查（instanceof）方法等。
  Klass* _super;          
  // 类加载器数据，每个类加载器都有其自己的命名空间，这意味着不同的类加载器可以加载名字相同但内容不同的类。这个指针让JVM可以追踪哪个类加载器加载特定的Klass。
  ClassLoaderData* _class_loader_data;  
  const KlassKind _kind;
  // 符号引用名
  Symbol*     _name;
  OopHandle   _java_mirror;
  int _vtable_len;
  AccessFlags _access_flags;
  // ... (其他成员)
};

  // 注解信息
  Annotations*    _annotations;
  // 包信息
  PackageEntry*   _package_entry;
  // 生成的数组类型
  ObjArrayKlass* volatile _array_klasses;
  // 内部类
  Array<jushort>* _inner_classes;
  // 常量池
  ConstantPool* _constants;
  // 类的状态，例如这个类初始化完成状态，或者未被初始化；
  volatile ClassState _init_state;          // state of class
  // 引用类型，软引用，弱引用等。
  u1              _reference_type;          // reference type
  // 各种标志位
  InstanceKlassFlags _misc_flags;
  // 监视器
  Monitor*             _init_monitor;       // mutual exclusion to _init_state and _init_thread.
  // 当前线程
  JavaThread* volatile _init_thread;        // Pointer to current thread doing initialization (to handle recursive initialization)

for(ci = 1; ci < len; ci++) {
          int cpConstType = tags.at(ci);
          // write cp_info
          // write constant type
          switch(cpConstType) {
              case JVM_CONSTANT_Utf8: {
				  // ...
                  break;
              }

              case JVM_CONSTANT_Unicode:
                  throw new IllegalArgumentException("Unicode constant!");

              case JVM_CONSTANT_Integer:
				  // ...
                  break;

              case JVM_CONSTANT_Float:
				  // ...
                  break;

              case JVM_CONSTANT_Long: {
				  // ...
                  break;
              }

              case JVM_CONSTANT_Double:
				  // ...
                  break;

              case JVM_CONSTANT_Class: {
				  // ...
                  break;
              }

              // case JVM_CONSTANT_ClassIndex:
              case JVM_CONSTANT_UnresolvedClassInError:
              case JVM_CONSTANT_UnresolvedClass: {
				  // ...
                  break;
              }

              case JVM_CONSTANT_String: {
				  // ...
                  break;
              }

              // all external, internal method/field references
              case JVM_CONSTANT_Fieldref:
              case JVM_CONSTANT_Methodref:
              case JVM_CONSTANT_InterfaceMethodref: {
				  // ...
                  break;
              }

              case JVM_CONSTANT_NameAndType: {
				  // ...
                  break;
              }

              case JVM_CONSTANT_MethodHandle: {
				  // ...
                  break;
              }

              case JVM_CONSTANT_MethodType: {
				  // ...
                  break;
              }

              case JVM_CONSTANT_InvokeDynamic: {
				  // ...
                  break;
              }

              default:
                  throw new InternalError("Unknown tag: " + cpConstType);
          } // switch
      }

// 在当前目录下的Building.class
javap -verbose .\Building.class

	// ...省略
Constant pool:
   #1 = Methodref          #17.#54        // java/lang/Object."<init>":()V
   #2 = Fieldref           #55.#56        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #57            // 建筑蓝图已被创建!
   #4 = Methodref          #58.#59        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Fieldref           #7.#60         // org/kfaino/webTemplate/jvm/Building.floorCount:I
   #6 = Fieldref           #7.#61         // org/kfaino/webTemplate/jvm/Building.constructionYear:I
   #7 = Class              #62            // org/kfaino/webTemplate/jvm/Building
   #8 = Methodref          #7.#54         // org/kfaino/webTemplate/jvm/Building."<init>":()V
   #9 = Class              #63            // java/lang/StringBuilder
  #10 = Methodref          #9.#54         // java/lang/StringBuilder."<init>":()V
  #11 = String             #64            // Building2{floorCount=
  #12 = Methodref          #9.#65         // java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  #13 = Methodref          #9.#66         // java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
  #14 = Methodref          #9.#67         // java/lang/StringBuilder.append:(C)Ljava/lang/StringBuilder;
  #15 = Methodref          #9.#68         // java/lang/StringBuilder.toString:()Ljava/lang/String;
  #16 = Methodref          #17.#69        // java/lang/Object.getClass:()Ljava/lang/Class;
  #17 = Class              #70            // java/lang/Object
  // ...省略

Map<WeakReference<Key>, Value> cache = new HashMap<>();

class Resource {
    private String id;

    public Resource(String id) {
        this.id = id;
    }
}

public class WeakReferenceWithQueueDemo {
    public static void main(String[] args) throws InterruptedException {
//        WeakHashMap<Object, Object> objectObjectWeakHashMap = new WeakHashMap<>();
        ReferenceQueue<Resource> referenceQueue = new ReferenceQueue<>();
        Map<WeakReference<Resource>, String> weakReferences = new HashMap<>();

        Resource resource = new Resource("RESOURCE_1");
        WeakReference<Resource> weakRef = new WeakReference<>(resource, referenceQueue);
        weakReferences.put(weakRef, "RESOURCE_1");
        // 清空强引用，只保留弱引用（试试把这里注释，你就看不到后面的打印语句了）
        resource = null;
        System.gc();

        Thread.sleep(1000);

        Reference<? extends Resource> removed;
        // 检查ReferenceQueue
        while ((removed = referenceQueue.poll()) != null) {
            String id = weakReferences.remove(removed);
            if (id != null) {
                System.out.println("Resource with ID: " + id + " 被垃圾回收了，我们来做一些额外的清理工作....");
            }
        }
    }
}

Resource with ID: RESOURCE_1 被垃圾回收了，我们来做一些额外的清理工作....
Process finished with exit code 0