最近在抽时间阅读 JDK 的源码，主要是 GC 还有 Safepoint 相关的源码，发现很多我在之前拜读网上各种 JVM 原理大作时候由于没有看源码导致我对于底层原理的误解。果然，一百个人读水浒传，就有一百种水浒传。还是需要更加深入的了解下源码，才能更好地理解 JVM，进行调优。这个系列，将在讲述 Java GC 各种原理的基础上，结合对应的源码分析，并附上源码地址。因为JVM的源码更新还是很快的，尤其是 GC 这一块，但是基本原理，应该大体不会变，附上源码地址，旨在让各位读者掌握这些原理最新实现情况。本文在撰写的时候，会紧跟最新版本的 JDK。
GC(Garbage Collection) 是目前很多编程语言自带的特性，例如Java，Python；GC是一个很好的特性，能让使用这个语言编程的程序员不去关心内存回收，并且降低内存泄漏和内存溢出发生的概率。
了解Java GC，需要先知道 Java 最基础的对象在内存中究竟是如何存储的。我们专注于 HotSpot 虚拟机实现，来详细阐述对象存储结构。首先我们来了解一个概念，对象指针（OOPs，Ordinary Object Pointers）, 也就是对象头的主要部分。
1. 对象指针（OOPs，Ordinary Object Pointers）对象指针的实现，可以参考oop.hpp：
class oopDesc { private: volatile markWord _mark; union _metadata { Klass* _klass; narrowKlass _compressed_klass; } _metadata; } 从源代码可以简单看出，对象指针包括：
1.标记字（Mark Word）： 一组标记，描述了对象的状态，包括对象默认哈希值（如果没有覆盖默认的 hashcode() 方法，则哈希值在 hashcode() 方法被调用之后，会被记录到标记字之中）、对象的形状（是否是数组）、锁状态（偏向锁等锁信息，值得一提的是偏向锁在 Java 15 中废弃：Disable and Deprecate Biased Locking）、数组长度（如果标记显示这个对象是数组，描述了数组的长度）。标记字的实现仅仅包含一个uintptr_t类型，所以，在 32 位和 64 位虚拟机上面，大小分别是 4 字节和 8 字节。可以参考源码： markWord.hpp。我们这里只讨论 64 位的 JVM，也就是标记字为 8 字节的情况。
class markWord { private: uintptr_t _value; } 2.类型字（Class Word）： 类型字是指向对象实现的 Class 的指针。Java 7 之前指向的区域位于持久带（Permanent Generation），Java 8 之后，持久带废弃，引入了元数据区的概念（Metaspace），所以Java 8 之后指向的是这个元数据区。
这个指针可能是被压缩的，就是压缩指针（Compressed OOPs）。当开启对象压缩时占用4字节（JVM默认开启），关闭时占用8字节
对于 64 位的虚拟机环境，标记字大小是 8 字节。先给出标记字结构：
（上图来自于：https://www.cnblogs.com/helloworldcode/p/11914053.html）
我们先来通过 jol （Java Object Layout） 工具，以及接下来的几个实例，来逐步看一下每种状态下的标记字结构。加入依赖：
org.openjdk.jol jol-core 0.13 如果类没有覆盖hashcode()，那么实现hashcode()的是一个native方法。
@HotSpotIntrinsicCandidate public native int hashCode(); 具体的实现参考源码synchronizer.cpp：
intptr_t ObjectSynchronizer::FastHashCode(Thread* self, oop obj) { //如果启用了偏向锁特性 if (UseBiasedLocking) { //如果正处于偏向锁 if (obj->mark().has_bias_pattern()) { //取消偏向锁，不会再处于偏向锁状态，并且在下次获取锁的时候，直接从轻量锁开始 Handle hobj(self, obj); if (SafepointSynchronize::is_at_safepoint()) { BiasedLocking::revoke_at_safepoint(hobj); } else { BiasedLocking::revoke(hobj, self); } obj = hobj(); assert(!obj->mark().has_bias_pattern(), "biases should be revoked by now"); } } while (true) { ObjectMonitor* mOnitor= NULL; markWord temp, test; intptr_t hash; markWord mark = read_stable_mark(obj); // 不能处于偏向锁状态 assert(!mark.has_bias_pattern(), "invariant"); // 未处于任何锁状态的一般状态 if (mark.is_neutral()) { hash = mark.hash(); if (hash != 0) { // 如果已经计算过哈希值，直接返回 return hash; } hash = get_next_hash(self, obj); // 否则，计算一个新的哈希值，这个方法的详细分析在另一篇文章 temp = mark.copy_set_hash(hash); // 设置哈希值 test = obj->cas_set_mark(temp, mark); //更新为设置成功 if (test == mark) { // 如果更新成功，则返回 return hash; } //如果设置失败，可能发生了锁膨胀，或者是多线程同时调用了hashcode方法，循环重新尝试 } else if (mark.has_monitor()) { //如果处于重量级锁状态 //获取对应的monitor对象 mOnitor= mark.monitor(); //获取其header temp = monitor->header(); assert(temp.is_neutral(), "invariant: header=" INTPTR_FORMAT, temp.value()); //查看header中的hashcode hash = temp.hash(); //若monitor中有哈希值，并且没有发生异步monitor降级（Async Monitor Deflation），就使用这个哈希值 //异步monitor降级（Async Monitor Deflation）,请参考：https://wiki.openjdk.java.net/display/HotSpot/Async+Monitor+Deflation，这是在 Java 15 之后开始引入的新特性 if (hash != 0) { // It has a hash. // Separate load of dmw/header above from the loads in // is_being_async_deflated(). if (support_IRIW_for_not_multiple_copy_atomic_cpu) { // A non-multiple copy atomic (nMCA) machine needs a bigger // hammer to separate the load above and the loads below. OrderAccess::fence(); } else { OrderAccess::loadload(); } if (monitor->is_being_async_deflated()) { // But we can't safely use the hash if we detect that async // deflation has occurred. So we attempt to restore the // header/dmw to the object's header so that we only retry // once if the deflater thread happens to be slow. monitor->install_displaced_markword_in_object(obj); continue; } return hash; } } else if (self->is_lock_owned((address)mark.locker())) { //如果处于轻量锁状态，读取指向锁记录的指针，获取其中的哈希值 temp = mark.displaced_mark_helper(); assert(temp.is_neutral(), "invariant: header=" INTPTR_FORMAT, temp.value()); hash = temp.hash(); if (hash != 0) { // if it has a hash, just return it return hash; } } //不处于以上状态或者处于以上锁状态之前，没有计算过哈希值，则直接膨胀锁到重量级锁 mOnitor= inflate(self, obj, inflate_cause_hash_code); //查看是否已经有其他线程计算过哈希值 mark = monitor->header(); assert(mark.is_neutral(), "invariant: header=" INTPTR_FORMAT, mark.value()); hash = mark.hash(); //如果没有，则在这里计算，并设置 if (hash == 0) { // if it does not have a hash hash = get_next_hash(self, obj); // get a new hash temp = mark.copy_set_hash(hash); // merge the hash into header assert(temp.is_neutral(), "invariant: header=" INTPTR_FORMAT, temp.value()); uintptr_t v = Atomic::cmpxchg((volatile uintptr_t*)monitor->header_addr(), mark.value(), temp.value()); test = markWord(v); //设置失败，则有其他线程已经设置，尝试读取 if (test != mark) { // The attempt to update the ObjectMonitor's header/dmw field // did not work. This can happen if another thread managed to // merge in the hash just before our cmpxchg(). // If we add any new usages of the header/dmw field, this code // will need to be updated. hash = test.hash(); assert(test.is_neutral(), "invariant: header=" INTPTR_FORMAT, test.value()); assert(hash != 0, "should only have lost the race to a thread that set a non-zero hash"); } //如果有发生异步monitor降级（Async Monitor Deflation），跳过，重新判断 //异步monitor降级（Async Monitor Deflation）,请参考：https://wiki.openjdk.java.net/display/HotSpot/Async+Monitor+Deflation，这是在 Java 15 之后开始引入的新特性 if (monitor->is_being_async_deflated()) { // If we detect that async deflation has occurred, then we // attempt to restore the header/dmw to the object's header // so that we only retry once if the deflater thread happens // to be slow. monitor->install_displaced_markword_in_object(obj); continue; } } // We finally get the hash. return hash; } } 可以看出，hashcode：
哈希值的具体计算，根据全局变量hashcode的值决定计算方式（通过-XX:hashCode=设定）。默认的哈希值计算，是hashcode=5 的情况，不同情况的计算方式的详细说明，如果感兴趣，可以参考：JDK核心JAVA源码解析(9) - hashcode 方法
我们来通过一段代码以及输出来看看这些特性
public static void main(String[] args) throws Exception { A a = new A(); B b = new B(); System.out.println("------After Initialization------\n" + ClassLayout.parseInstance(a).toPrintable() + "\n" + ClassLayout.parseInstance(b).toPrintable()); System.out.println("a.hashcode: " + a.hashCode()); System.out.println("b.hashcode: " + b.hashCode()); System.out.println("------After call hashcode------\n" + ClassLayout.parseInstance(a).toPrintable() + "\n" + ClassLayout.parseInstance(b).toPrintable()); } //A没有覆盖默认的 hashcode 方法 public static class A { long d; } //B覆盖了 hashcode 方法 public static class B { long d; @Override public int hashCode() { return (int) 5555; } } 输出：
------After Initialization------ com.hashjang.jdk.TestObjectAlign$A object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 05 00 00 00 (00000101 00000000 00000000 00000000) (5) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) 49 ce 00 20 (01001001 11001110 00000000 00100000) (536923721) 12 4 (alignment/padding gap) 16 8 long A.d 0 Instance size: 24 bytes Space losses: 4 bytes internal + 0 bytes external = 4 bytes total com.hashjang.jdk.TestObjectAlign$B object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 05 00 00 00 (00000101 00000000 00000000 00000000) (5) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) 8a ce 00 20 (10001010 11001110 00000000 00100000) (536923786) 12 4 (alignment/padding gap) 16 8 long B.d 0 Instance size: 24 bytes Space losses: 4 bytes internal + 0 bytes external = 4 bytes total a.hashcode: 2124046270 b.hashcode: 5555 ------After call hashcode------ com.hashjang.jdk.TestObjectAlign$A object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 01 be 5f 9a (00000001 10111110 01011111 10011010) (-1705001471) 4 4 (object header) 7e 00 00 00 (01111110 00000000 00000000 00000000) (126) 8 4 (object header) 49 ce 00 20 (01001001 11001110 00000000 00100000) (536923721) 12 4 (alignment/padding gap) 16 8 long A.d 0 Instance size: 24 bytes Space losses: 4 bytes internal + 0 bytes external = 4 bytes total com.hashjang.jdk.TestObjectAlign$B object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 05 00 00 00 (00000101 00000000 00000000 00000000) (5) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) 8a ce 00 20 (10001010 11001110 00000000 00100000) (536923786) 12 4 (alignment/padding gap) 16 8 long B.d 0 Instance size: 24 bytes Space losses: 4 bytes internal + 0 bytes external = 4 bytes total 可以看出，对于未覆盖hashcode()方法的 A 类，调用hashcode()之后，哈希值存在了对象头。哈希值为 2124046270，转换为二进制为：1111110 10011010 01011111 10111110。由于 Windows 系统中为小端存储，所以打印出来的 Header 是反过来的，可以看到这个哈希值就存储在 Header 中：
00000001 10111110 01011111 10011010 01111110 00000000 00000000 00000000
其他特性，将在接下来的 1.1.3. 偏向锁，轻量锁，重量锁 这一小节详细说明。
对象头中的分代年龄，用于分代 GC。分代 GC 我们在后面的章节会详细讲述，这里只是看一些特性。
记录分代年龄一共 4 bit，所以最大为 2^4 - 1 = 15。所以配置最大分代年龄-XX:MaxTenuringThreshold=n这个n不能大于15，当然也不能小于 0.等于 0 的话，就直接入老年代。等于 16 的话，就是从不进入老年代，这样不符合JVM规范，所以不能大于15（感谢 CSDN @JonsonJiao 指正）。默认是 15。
在发生 Young GC，更准确地说是在 Survivor 区复制的时候，存活的对象的分代年龄会加1。我们编写程序测试下，由于 编译器会优化代码，同时调用System.gc()并不是立刻触发 GC，并且是 Full GC，可能会使对象直接进入老年代，分代年龄不再增长，所以我们可以使用 volatile 属性辅助我们真正创建对象，避免编译器优化：
static volatile Object consumer; public static void main(String[] args) throws Exception { //这是我们要观察的对象 Object instance = new Object(); long lastAddr = VM.current().addressOf(instance); for (int i = 0; i <10000; i++) { //查看地址是否发生了变化，代表是否发生了 Survivor 复制，或者是移动到老年代 long currentAddr = VM.current().addressOf(instance); if (currentAddr != lastAddr) { //地址发生变化的时候，打印对象结构 ClassLayout layout = ClassLayout.parseInstance(instance); System.out.println(layout.toPrintable()); lastAddr = currentAddr; } for (int j = 0; j <10000; j++) { //一直创建新对象 //因为是volatile的属性更新，不会被编译器优化 cOnsumer= new Object(); } } } 可以配合 GC 日志一起观察，关于 JVM 日志配置可以参考这篇文章：OpenJDK 11 JVM日志相关参数解析与使用
首先我们用这个参数运行程序-Xmx128m -Xlog:gc=info，输出：
[0.016s][info][gc] Using G1 # WARNING: Unable to get Instrumentation. Dynamic Attach failed. You may add this JAR as -javaagent manually, or supply -Djdk.attach.allowAttachSelf [2.540s][info][gc] GC(0) Pause Young (Normal) (G1 Evacuation Pause) 24M->1M(128M) 2.600ms java.lang.Object object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 0d 00 00 00 (00001101 00000000 00000000 00000000) (13) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) 00 02 00 20 (00000000 00000010 00000000 00100000) (536871424) 12 4 (loss due to the next object alignment) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total [2.627s][info][gc] GC(1) Pause Young (Normal) (G1 Evacuation Pause) 75M->1M(128M) 2.273ms java.lang.Object object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 15 00 00 00 (00010101 00000000 00000000 00000000) (21) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) 00 02 00 20 (00000000 00000010 00000000 00100000) (536871424) 12 4 (loss due to the next object alignment) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total [2.675s][info][gc] GC(2) Pause Young (Normal) (G1 Evacuation Pause) 75M->1M(128M) 2.063ms java.lang.Object object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 1d 00 00 00 (00011101 00000000 00000000 00000000) (29) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) 00 02 00 20 (00000000 00000010 00000000 00100000) (536871424) 12 4 (loss due to the next object alignment) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total [2.724s][info][gc] GC(3) Pause Young (Normal) (G1 Evacuation Pause) 75M->1M(128M) 2.068ms java.lang.Object object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 25 00 00 00 (00100101 00000000 00000000 00000000) (37) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) 00 02 00 20 (00000000 00000010 00000000 00100000) (536871424) 12 4 (loss due to the next object alignment) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total [2.772s][info][gc] GC(4) Pause Young (Normal) (G1 Evacuation Pause) 75M->1M(128M) 2.212ms java.lang.Object object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 2d 00 00 00 (00101101 00000000 00000000 00000000) (45) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) 00 02 00 20 (00000000 00000010 00000000 00100000) (536871424) 12 4 (loss due to the next object alignment) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total [2.821s][info][gc] GC(5) Pause Young (Normal) (G1 Evacuation Pause) 75M->1M(128M) 2.202ms java.lang.Object object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 35 00 00 00 (00110101 00000000 00000000 00000000) (53) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) 00 02 00 20 (00000000 00000010 00000000 00100000) (536871424) 12 4 (loss due to the next object alignment) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total [2.869s][info][gc] GC(6) Pause Young (Normal) (G1 Evacuation Pause) 75M->1M(128M) 2.143ms java.lang.Object object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 3d 00 00 00 (00111101 00000000 00000000 00000000) (61) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) 00 02 00 20 (00000000 00000010 00000000 00100000) (536871424) 12 4 (loss due to the next object alignment) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total [2.917s][info][gc] GC(7) Pause Young (Normal) (G1 Evacuation Pause) 75M->1M(128M) 2.313ms java.lang.Object object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 45 00 00 00 (01000101 00000000 00000000 00000000) (69) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) 00 02 00 20 (00000000 00000010 00000000 00100000) (536871424) 12 4 (loss due to the next object alignment) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total [2.969s][info][gc] GC(8) Pause Young (Normal) (G1 Evacuation Pause) 75M->1M(128M) 2.473ms java.lang.Object object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 4d 00 00 00 (01001101 00000000 00000000 00000000) (77) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) 00 02 00 20 (00000000 00000010 00000000 00100000) (536871424) 12 4 (loss due to the next object alignment) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total [3.021s][info][gc] GC(9) Pause Young (Normal) (G1 Evacuation Pause) 75M->1M(128M) 2.283ms java.lang.Object object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 55 00 00 00 (01010101 00000000 00000000 00000000) (85) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) 00 02 00 20 (00000000 00000010 00000000 00100000) (536871424) 12 4 (loss due to the next object alignment) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total [3.072s][info][gc] GC(10) Pause Young (Normal) (G1 Evacuation Pause) 75M->1M(128M) 2.648ms java.lang.Object object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 5d 00 00 00 (01011101 00000000 00000000 00000000) (93) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) 00 02 00 20 (00000000 00000010 00000000 00100000) (536871424) 12 4 (loss due to the next object alignment) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total [3.122s][info][gc] GC(11) Pause Young (Normal) (G1 Evacuation Pause) 75M->1M(128M) 2.585ms java.lang.Object object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 65 00 00 00 (01100101 00000000 00000000 00000000) (101) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) 00 02 00 20 (00000000 00000010 00000000 00100000) (536871424) 12 4 (loss due to the next object alignment) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total [3.173s][info][gc] GC(12) Pause Young (Normal) (G1 Evacuation Pause) 75M->1M(128M) 2.130ms java.lang.Object object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 6d 00 00 00 (01101101 00000000 00000000 00000000) (109) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) 00 02 00 20 (00000000 00000010 00000000 00100000) (536871424) 12 4 (loss due to the next object alignment) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total [3.224s][info][gc] GC(13) Pause Young (Normal) (G1 Evacuation Pause) 75M->1M(128M) 2.078ms java.lang.Object object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 75 00 00 00 (01110101 00000000 00000000 00000000) (117) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) 00 02 00 20 (00000000 00000010 00000000 00100000) (536871424) 12 4 (loss due to the next object alignment) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total [3.273s][info][gc] GC(14) Pause Young (Normal) (G1 Evacuation Pause) 75M->1M(128M) 2.135ms java.lang.Object object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 7d 00 00 00 (01111101 00000000 00000000 00000000) (125) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) 00 02 00 20 (00000000 00000010 00000000 00100000) (536871424) 12 4 (loss due to the next object alignment) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total [3.322s][info][gc] GC(15) Pause Young (Normal) (G1 Evacuation Pause) 75M->1M(128M) 2.467ms java.lang.Object object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 7d 00 00 00 (01111101 00000000 00000000 00000000) (125) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) 00 02 00 20 (00000000 00000010 00000000 00100000) (536871424) 12 4 (loss due to the next object alignment) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total [3.404s][info][gc] GC(16) Pause Young (Normal) (G1 Evacuation Pause) 76M->1M(128M) 0.556ms [3.485s][info][gc] GC(17) Pause Young (Normal) (G1 Evacuation Pause) 76M->1M(128M) 0.303ms [3.566s][info][gc] GC(18) Pause Young (Normal) (G1 Evacuation Pause) 76M->1M(128M) 0.288ms [3.647s][info][gc] GC(19) Pause Young (Normal) (G1 Evacuation Pause) 76M->1M(128M) 0.317ms [3.727s][info][gc] GC(20) Pause Young (Normal) (G1 Evacuation Pause) 76M->1M(128M) 0.286ms 可以看到，在第 15 次 GC 的时候，对象进入了老年代，内存地址不再随着 Young GC 的进行而变化。
各位读者可以将-XX:MaxTenuringThreshold=设置为 0 和 16 看看效果。
我们来编写测试代码：
A a = new A(); System.out.println("------After Initialization------\n" + ClassLayout.parseInstance(a).toPrintable()); //偏向锁 synchronized (a) { System.out.println("------After Fetched Lock------\n" + ClassLayout.parseInstance(a).toPrintable()); } System.out.println("------After Released Lock------\n" + ClassLayout.parseInstance(a).toPrintable()); System.out.println("a.hashcode: " + a.hashCode()); System.out.println("------After call hashcode------\n" + ClassLayout.parseInstance(a).toPrintable()); //由于调用了 hashcode，这里直接升级成为轻量锁 synchronized (a) { System.out.println("------After Fetched Lock------\n" + ClassLayout.parseInstance(a).toPrintable()); } System.out.println("------After Released Lock------\n" + ClassLayout.parseInstance(a).toPrintable()); //测试重量级锁 Runnable r = () -> { synchronized (a) { System.out.println("------After " + Thread.currentThread() + " lock is fetched------\n" + ClassLayout.parseInstance(a).toPrintable()); try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } } }; Thread [] threads = new Thread[2]; for (int i = 0; i 输出为(我们这里省略掉我们不关心的输出)：
------After Initialization------ OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 05 00 00 00 (00000101 00000000 00000000 00000000) (5) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) ------After Fetched Lock------ OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 05 90 8a 5e (00000101 10010000 10001010 01011110) (1586139141) 4 4 (object header) c7 02 00 00 (11000111 00000010 00000000 00000000) (711) ------After Released Lock------ OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 05 90 8a 5e (00000101 10010000 10001010 01011110) (1586139141) 4 4 (object header) c7 02 00 00 (11000111 00000010 00000000 00000000) (711) a.hashcode: 929776179 ------After call hashcode------ OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 01 33 42 6b (00000001 00110011 01000010 01101011) (1799500545) 4 4 (object header) 37 00 00 00 (00110111 00000000 00000000 00000000) (55) ------After Fetched Lock------ OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 78 f2 0f 53 (01111000 11110010 00001111 01010011) (1393554040) 4 4 (object header) ee 00 00 00 (11101110 00000000 00000000 00000000) (238) ------After Released Lock------ OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 01 33 42 6b (00000001 00110011 01000010 01101011) (1799500545) 4 4 (object header) 37 00 00 00 (00110111 00000000 00000000 00000000) (55) ------After Thread[Thread-0,5,main] lock is fetched------ OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 02 3e e0 b0 (00000010 00111110 11100000 10110000) (-1327481342) 4 4 (object header) 69 02 00 00 (01101001 00000010 00000000 00000000) (617) ------After Thread[Thread-1,5,main] lock is fetched------ OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 02 3e e0 b0 (00000010 00111110 11100000 10110000) (-1327481342) 4 4 (object header) 69 02 00 00 (01101001 00000010 00000000 00000000) (617) ------After Released Lock------ OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 02 3e e0 b0 (00000010 00111110 11100000 10110000) (-1327481342) 4 4 (object header) 69 02 00 00 (01101001 00000010 00000000 00000000) (617) 我们这里通过第一字节 8 位的末尾两位判断锁状态：
压缩指针这个属性默认是打开的，可以通过-XX:-UseCompressedOops关闭。
首先说一下为何需要压缩指针呢？32 位的存储，可以描述多大的内存呢？假设每一个1代表1字节，那么可以描述 0~2^32-1 这 2^32 字节也就是 4 GB 的内存。
但是呢，Java 默认是 8 字节对齐的内存，也就是一个对象占用的空间，必须是 8 字节的整数倍，不足的话会填充到 8 字节的整数倍。也就是其实描述内存的时候，不用从 0 开始描述到 8（就是根本不需要定位到之间的1，2，3，4，5，6，7）因为对象起止肯定都是 8 的整数倍。所以，2^32 字节如果一个1代表8字节的话，那么最多可以描述 2^32 * 8 字节也就是 32 GB 的内存。
这就是压缩指针的原理。如果配置最大堆内存超过 32 GB（当 JVM 是 8 字节对齐），那么压缩指针会失效。 但是，这个 32 GB 是和字节对齐大小相关的，也就是-XX:ObjectAlignmentInBytes配置的大小(默认为8字节，也就是 Java 默认是 8 字节对齐)。-XX:ObjectAlignmentInBytes可以设置为 8 的整数倍，最大 128。也就是如果配置-XX:ObjectAlignmentInBytes为 24，那么配置最大堆内存超过 96 GB 压缩指针才会失效。
编写程序测试下：
A a = new A(); System.out.println("------After Initialization------\n" + ClassLayout.parseInstance(a).toPrintable()); 首先，以启动参数：-XX:ObjectAlignmentInBytes=8 -Xmx16g执行：
------After Initialization------ com.hashjang.jdk.TestObjectAlign$A object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 05 00 00 00 (00000101 00000000 00000000 00000000) (5) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) 48 72 06 00 (01001000 01110010 00000110 00000000) (422472) 12 4 (alignment/padding gap) 16 8 long A.d 0 Instance size: 24 bytes Space losses: 4 bytes internal + 0 bytes external = 4 bytes total 可以看到类型字大小为 4 字节48 72 06 00 (01001000 01110010 00000110 00000000) (422472)，压缩指针生效。
首先，以启动参数：-XX:ObjectAlignmentInBytes=8 -Xmx32g执行：
------After Initialization------ com.hashjang.jdk.TestObjectAlign$A object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 05 00 00 00 (00000101 00000000 00000000 00000000) (5) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) a0 5b c6 00 (10100000 01011011 11000110 00000000) (12999584) 12 4 (object header) b4 02 00 00 (10110100 00000010 00000000 00000000) (692) 16 8 long A.d 0 Instance size: 24 bytes Space losses: 0 bytes internal + 0 bytes external = 0 bytes total 可以看到类型字大小为 8 字节，压缩指针失效:
a0 5b c6 00 (10100000 01011011 11000110 00000000) (12999584) b4 02 00 00 (10110100 00000010 00000000 00000000) (692) 修改对齐大小为 16 字节，也就是以-XX:ObjectAlignmentInBytes=16 -Xmx32g执行：
------After Initialization------ com.hashjang.jdk.TestObjectAlign$A object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 05 00 00 00 (00000101 00000000 00000000 00000000) (5) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) 48 72 06 00 (01001000 01110010 00000110 00000000) (422472) 12 4 (alignment/padding gap) 16 8 long A.d 0 24 8 (loss due to the next object alignment) Instance size: 32 bytes Space losses: 4 bytes internal + 8 bytes external = 12 bytes total 可以看到类型字大小为 4 字节48 72 06 00 (01001000 01110010 00000110 00000000) (422472)，压缩指针生效。
-XX:MaxTenuringThreshold=n配置的值，大于这个值就进入老年代了。-XX:ObjectAlignmentInBytes，默认是 8，也就是 8 字节对齐）还有最大堆栈大小相关。![python的交互模式怎么输出名文汉字[python常见问题]](https://img1.php1.cn/3cd4a/24cea/978/9f39a0b333a15215.gif)
