JVM 内存分配机制，一次讲够！

概述

本文主要讲述 JVM 内存分配机制细节, 包含如下内容：

1. Java 对象创建过程
2. 对象的内存结构和指针压缩
3. 对象的内存分配过程
4. 逃逸分析
5. 内存回收策略
6. 4 种引用类型

本文所提到的 JVM 分配都是基于 ​​jdk-1.8​​ 版本

JVM 内存分配机制

一、JVM 对象创建过程

1. 类加载检查

虚拟机遇到一条 new 指令时，首先会检查这个指令的参数能否在常量池里面定位到一个类的符号引用，并且检查这个符号引用代表的类是否被加载、解析和初始化过。如果没有，那必须先执行相应的类加载过程。

new 指令对应到语言层面上讲的是，new 关键字、对象克隆、对象序列化等。

2. 内存分配

在类加载检查通过过后，接下来对象将为新生对象分配内存。对象所需内存的大小在类加载完成后便可完全确定，为对象分空间的任务等同于把一块确定大小的内存从 Java 堆中划分出来。

这个步骤需要解决两个问题：

1. 如何换分内存。
2. 在并发情况下， 可能出现正在给对象 A 分配内存，指针还没有来得及修改，对象 B 又同时使用来原来的指针来分配内存的情况。

划分内存的方法

1. “指针碰撞” (Bump the Pointer ) (默认使用指针碰撞)。 如果 Java 堆中内存是绝对规整的，所有用过的内存在一边，空闲的内存在另外一边，中间放着一个指针作为分界点的指示器，那所分配内存就仅仅是把哪个指针指向空闲空间挪动一段对象大小相等的距离
2. “空闲列表” (Free List）如果 Java 堆中的空间并不是规整的，已使用的内存空间和空闲的内存空间相互交错，那么就没有办法简单的进行指针碰撞了，虚拟机就需要维护一个列表，记录那些内存是使用过的，那些是没有使用过的。

解决并发问题

1. CAS （compare and swap）, 虚拟机采用 CAS 并发分配重试的方式保证更新操作的原子性来堆分配内存空间的动作进行同步处理。
2. 本地线程分配缓冲（Thread Local Allocation Buffer, TLAB），把内存分配的动作按照线程不同的空间中进行，即每个线程在 Java 堆中预先分配一小块内存。通过​​-XX:+/-UseTLAB​​​ 参数来设定虚拟机是否使用 TLAB (Jvm 会默认开启​​-XX:+UseTLAB​​​ )， 通过​​-XX:TLABSize​​ 指定 TLAB 大小。

4. 初始化

内存分配完成后，虚拟机需要将分配到的内存空间都初始化为零值（不包括对象头），如果使用 TLAB , 这一工作也可以提前 TLAB 分配进行。这一步骤保证了对象的实例字段在 Java 代码中可以不赋初始值就直接使用，程序能访问这些字段的数据类型对应的零值。

5. 设置对象头

初始化零值分配后，虚拟机要进行必要的设置，例如设置这个对象是哪个实例，如何能够得到类的元数据信息、对象的哈希码、对象的 GC 分代年龄等信息，这些信息都存放在对象头（Object Header）中。

在 HotSpot 虚拟机里，对象在堆内存中的存储布局可以划分为三个部分：对象头（Header）、实例数据（Instance Data）和对齐填充（Padding）。

HotSpot虚拟机对象的对象头部分包括两类信息。第一类是用于存储对象自身的运行时数据，如哈希码（HashCode）、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等。对象头的另外一部分是类型指针，即对象指向它的类型元数据的指针，Java虚拟机通过这个指针来确定该对象是哪个类的实例。

对象头在 hotspot 虚拟机中的源码 markOop.cpp

// Bit-format of an object header (most significant first, big endian layout below):
//
//  32 bits:
//  --------
//             hash:25 ------------>| age:4    biased_lock:1 lock:2 (normal object)
//             JavaThread*:23 epoch:2 age:4    biased_lock:1 lock:2 (biased object)
//             size:32 ------------------------------------------>| (CMS free block)
//             PromotedObject*:29 ---------->| promo_bits:3 ----->| (CMS promoted object)
//
//  64 bits:
//  --------
//  unused:25 hash:31 -->| unused:1   age:4    biased_lock:1 lock:2 (normal object)
//  JavaThread*:54 epoch:2 unused:1   age:4    biased_lock:1 lock:2 (biased object)
//  PromotedObject*:61 --------------------->| promo_bits:3 ----->| (CMS promoted object)
//  size:64 ----------------------------------------------------->| (CMS free block)
//
//  unused:25 hash:31 -->| cms_free:1 age:4    biased_lock:1 lock:2 (COOPs && normal object)
//  JavaThread*:54 epoch:2 cms_free:1 age:4    biased_lock:1 lock:2 (COOPs && biased object)
//  narrowOop:32 unused:24 cms_free:1 unused:4 promo_bits:3 ----->| (COOPs && CMS promoted object)
//  unused:21 size:35 -->| cms_free:1 unused:7 ------------------>| (COOPs && CMS free block)

6. 调用​​<init>​​ 方法

执行 ​​<init>​​ 方法, 即按照程序开发者的意愿进行初始化。对应到语言的层面上来说，就是为属性赋值（注意，这上面的赋零值不同，这是由程序开发者赋的值）和执行构造方法。

二、对象大小与指针压缩

对象的结构我们可以通过 ​​org.openjdk.jol:jol-core​​ 打印内存的布局信息

maven 依赖代码：

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

测试代码

public class ClassLayoutTest {

    public static void main(String[] args) {
        ClassLayout layout1 = ClassLayout.parseInstance(new Object());
        System.out.println(layout1.toPrintable());

        System.out.println();
        ClassLayout layout2 = ClassLayout.parseInstance(new int[]{});
        System.out.println(layout2.toPrintable());

        System.out.println();
        ClassLayout layout3 = ClassLayout.parseInstance(new A());
        System.out.println(layout3.toPrintable());
    }

    //-XX:+UseCompressedOops          默认开启的压缩所有指针
    //-XX:+UseCompressedClassPointers 默认开启的只压缩对象头里的类型指针 Klass Pointer
    //Oops: Ordinary Object Pointers
    public static class A {
                        //8B  mark word
                        //4B Klass Pointer 如果关闭 -XX:-UseCompressedClassPointers 或者 -XX:-UseCompressedOops, 则占 8个字节
        int id;         //4B
        String name;    //4B 如果关闭 -XX:-UseCompressedOops, 则占 8个字节
        byte b;         //1B
        Object o;       //4B 如果关闭 -XX:-UseCompressedOops, 则占 8个字节

    }
}

输出结果

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


[I 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)                           6d 01 00 f8 (01101101 00000001 00000000 11111000) (-134217363)
     12     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
     16     0    int [I.<elements>                             N/A
Instance size: 16 bytes
Space losses: 0 bytes internal + 0 bytes external = 0 bytes total


com.jvm.ClassLayoutTest$A 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)                           57 e0 00 f8 (01010111 11100000 00000000 11111000) (-134160297)
     12     4                int A.id                                      0
     16     4   java.lang.String A.name                                    null
     20     4   java.lang.Object A.object                                  null
Instance size: 24 bytes
Space losses: 0 bytes internal + 0 bytes external = 0 bytes total

什么是 Java 对象的指针压缩？

1. jdk1.6 update14开始, 在 64bit操作系统中, JVM 支持指针压缩
2. jvm配置参数: UseCompressedOops, compressed--压缩、oop( ordinary object pointer)-对象指针
3. 启用指针压缩: -XX:+UseCompressedOops(默认开启), 禁止指针压缩: -XX:-UseCompressedOops

为什么要进行指针压缩?

1. 在 64 位平台的 Hotspot 中使用 32 位指针(实际存储用64位)内存使用会多出1.5倍左右, 使用较大指针在主内存和缓存之间移动数据,占用较大宽带, 同时GC也会承受较大压力。
2. 为了减少64位平台下内存的消耗, 启用指针压缩功能
3. 在jvm中, 32 位地址最大支持4G内存(2的32次方), 可以通过对对象指针的存入堆内存时压缩编码、取出到cpu寄存器后解码方式进行优化(对象指针在堆中是32位,在寄存器中是35位,2的35次方=32G), 使得jvm只用32位地址就可以支持更大的内存配置(小于等于32G)
4. 堆内存小于 4G 时,不需要启用指针压缩, jvm 会直接去除高 32 位地址, 即使用低虚拟地址空间
5. 堆内存大于 32G 时压指针会生效会强制使用64位(即8字节)来对 Java 象寻址，这就会出视1的问题，所以堆内存不要大于 32G 为好。

关于对齐填充： 对于大部分处理器，对象以 8 字节整数倍来对齐填充都是最高效的存取方式。

三、JVM 对象内存分配过程

四、逃逸分析（Escape Analysis）

逃逸分析是 Java 虚拟机的优化技术，逃逸分析的原理是：分析对动态作用域， 当一个对象在方法区里面被定义后，它可能被外部方法引用，例如作为调用参数传递给其他方法中，这种称为方法逃逸；甚至还有可能被外部线程访问到，譬如直接赋值给可以在其他线程访问的实例变量，这种称为线程逃逸；从不逃逸、方法逃逸、到线程逃逸，称为对象由低到高的不同逃逸程度。

栈上分配（Stack Allocations）

很显然test方法中的user对象被返回了,这个对象的作用域范围不确定,test2方法中的user对象我们可以确定当方法结束这个对象就可以认为是无效对象了,对于这样的对象我们其实可以将其分配在栈内存里,让其在方法结束时跟随栈内存一起被回收掉JM对于这种情况可以通过开启逃逸分析参数(-XX:+Doescapeanalysis 屎来优化对象内存分配位置,使其通过标量替换优先分配在栈上(栈上分配), Jdk7之后默认开启逃逸分析, 如果要关闭使用参数(-XX:+Doescapeanalysis)

标量替换（Scalar Replacement）

1. 标量替换

通过逃逸分析确定该对象不会被外部访问, 并且对象可以被进一步分解时,JVM 不会创建该对象,而是将该对象成员变量分解若干个被这个方法使用的成员变量所代替, 这些代替的成员变量在栈帧或寄存器上分配空间, 这样就不会因为没有一大块连续空间导致对象内存不够分配。开启标量替换参数(-XX:+Eliminateallocations), JDK7 之后默认开启。

2. 标量与聚合量

标量即不可被进一步分解的量, 而 Java 的基本数据类型就是标量(如:int,long等基本数据类型以及 reference类型等), 标量的对立就是可以被进一步分解的量, 而这种量称之为聚合量。而在 JAVA 中对象就是可以被进一步分解的聚合量。

3. 案例演示

// 未被优化前的代码
public int test(int x) {
  int xx = x + 2;
  Point p = new Point(xx, 43);
  return p.getX();
}

class Point {
  private int x,
  private int y,

  public Point(int x, int y) {
    this.x = x;
    this.y = y;
  }

  public int getX() {
    return this.x;
  }
}

首先进行内联优化

// 内联优化
public int test(int x) {
  int xx = x + 2;
  Point p = point_memory_alloc();
  p.x = xx;
  p.y = 42
  return p.x;
}

然后进行逃逸分析，发现在 test 犯法中 Point 对象实例不会发生任何逃逸，这样就可以对它进行标量替换优化，把内部的 x 和 y 直接置换出来分解为 test() 方法内的局部变量，从而避免 Point 对象实例被实际创建。优化后的代码

// 标量替换
public int test(int x) {
  int xx = x + 2;
  int px = xx;
  int py = 42
  return px;
}

// 最终优化
public int test(int x) {
  return x + 2;
}

五、内存分配回收策略

对象优先分配在 Eden 区

大多数情况下，对象在新生代 Eden 区中分配。当Eden区没有足够空间进行分配时，虚拟机将发起一次 Minor GC。 HotSpot虚拟机提供了​​-XX:+PrintGCDetails​​ 这个收集器日志参数，告诉虚拟机在发生垃圾收集行为时打印内存回收日志，并且在进程退出的时候输出当前的内存各区域分配情况。

测试代码：

/**
 * -XX:+PrintGCDetails
 */
public class GCTest {

    public static void main(String[] args) {
        byte[] allcation2 = new byte[8000 * 1024];
    }
}

输出结果

Heap
 PSYoungGen      total 38400K, used 11353K [0x0000000795580000, 0x0000000798000000, 0x00000007c0000000)
  eden space 33280K, 34% used [0x0000000795580000,0x00000007960966f8,0x0000000797600000)
  from space 5120K, 0% used [0x0000000797b00000,0x0000000797b00000,0x0000000798000000)
  to   space 5120K, 0% used [0x0000000797600000,0x0000000797600000,0x0000000797b00000)
 ParOldGen       total 87552K, used 0K [0x0000000740000000, 0x0000000745580000, 0x0000000795580000)
  object space 87552K, 0% used [0x0000000740000000,0x0000000740000000,0x0000000745580000)
 Metaspace       used 3017K, capacity 4556K, committed 4864K, reserved 1056768K
  class space    used 319K, capacity 392K, committed 512K, reserved 1048576K

我们可以通过内存空间的分布可以看出 ​​allcation2​​ 是被分配到 eden 区中的。

大对象直接进入老年代

大对象就是指需要大量连续内存空间的Java对象（比如：字符串、数组），JVM 参数 ​​-XX:PretenureSizeThreshold​​ 参数可以设置大对象的大小，指定大于该设置值的对象直接在老年代分配，不会进入年轻代，这个参数只有在 Serial 和 ParNew 两个收集器下有效。

比如设置：JVM 参数：-XX:PretenureSizeThreshold=1000000（单位直接）-XX:+UseSerialGC, 在执行上面的第一个程序就会发现大对象直接进入了老年代。

这样做的目的就是避免在Eden区及两个Survivor区之间来回复制，产生大量的内存复制操作。

长期存活的对象将进入老年代

HotSpot虚拟机中多数收集器都采用了分代收集来管理堆内存，那内存回收时就必须能决策哪些存活对象应当放在新生代，哪些存活对象放在老年代中。为做到这点，虚拟机给每个对象定义了一个对象年龄（Age）计数器，存储在对象头中。

对象通常在Eden区里诞生，如果经过第一次 Minor GC 后仍然存活，并且能被 Survivor 容纳的话，该对象会被移动到 Survivor 空间中，并且将其对象年龄设为1岁。对象在Survivor区中每熬过一次Minor GC，年龄就增加1岁，当它的年龄增加到一定程度（默认为15），就会被晋升到老年代中。对象晋升老年代的年龄阈值，可以通过参数 ​​-XX:MaxTenuringThreshold​​ 设置。

动态对象年龄判断

为了能更好地适应不同程序的内存状况，HotSpot 虚拟机并不是永远要求对象的年龄必须达到 -XX:MaxTenuringThreshold 才能晋升老年代，如果在 Survivor 空间中相同年龄所有对象大小的总和大于 Survivor 空间的一半，年龄大于或等于该年龄的对象就可以直接进入老年代，无须等到 -XX:MaxTenuringThreshold 中要求的年龄。

空间分配担保

在发生 Minor GC 之前，虚拟机必须先检查老年代最大可用的连续空间是否大于新生代所有对象总空间。

如果这个条件成立，那这一次Minor GC可以确保是安全的。如果不成立，则虚拟机会先查看​​-XX:HandlePromotionFailure​​参数的设置值是否允许担保失败（Handle Promotion Failure）；

如果允许，那会继续检查老年代最大可用的连续空间是否大于历次晋升到老年代对象的平均大小，

如果大于，将尝试进行一次 Minor GC，尽管这次 Minor GC 是有风险的；

如果小于，或者 ​​-XX:HandlePromotionFailure​​ 设置不允许冒险，那这时就要改为进行一次 Full GC。

空间担保过程

六、对象内存回收

引用计数法

在对象中添加一个引用计数器，每当有一个地方 引用它时，计数器值就加一；当引用失效时，计数器值就减一；任何时刻计数器为零的对象就是不可能再被使用的。

这个方法实现很简单，效率很高, 但是目前的主流虚拟机并没有悬着这个算法来管理内存，其中主要的运用就是它很难解决对象之间相互循环应用的问题，对象之间的相互引用问题，如下面的代码所示对象objA和objB都有字段instance，赋值令 objA.instance=objB及objB.instance=objA，除此之外，这两个对象再无任何引用，实际上这两个对象已经不可能再被访问，但是它们因为互相引用着对方，导致它们的引用计数都不为零，引用计数算法也就无法回收它们。

public class ReferenceCountingGC {
    public Object instance = null;

    public static void main(String[] args) {
        ReferenceCountingGC objA = new ReferenceCountingGC();
        ReferenceCountingGC objB = new ReferenceCountingGC();
        objA.instance = objB;
        objB.instance = objA;
        objA = null;
        objB = null;
    }
}

可达性分析算法

将 “GC Roots” 作为对象的起点，从这里开始向下搜索引用对象，找到的对象都标记为非垃圾对象，其余未标记的对象都是垃圾对象。

GC Root 根节点：线程栈的本地变量、静态变量，本地方法栈变量等等。

七、常见的引用类型

强引用

• 只要存在强引用，垃圾收集器永远不会回收 例如：Object obj = new Object();
• 帮助垃圾对象回收 obj = null, ArrayList 源码实现

/**
 * Removes all of the elements from this list.  The list will
 * be empty after this call returns.
 */
public void clear() {
    modCount++;

    // clear to let GC do its work
    for (int i = 0; i < size; i++)
        elementData[i] = null;

    size = 0;
}

软引用

• 用来描述一些还有用但并非必须的对象。对于软应用关联着的对象，在系统将要发生内存泄漏溢出（Full GC ）之前， 将会把这些对象列进回收范围之中进行二次回收，如果这次回收还没有足够的内存，就会抛出OOM（内存溢出）异常。
• 在JDK1.2 之后提供了SoftReference类来实现软引用， 这个特征非常适合在：网页缓存、图片缓存等。
• ​​//获取页面进行浏览 Browser prev = new Browser(); //浏览完毕后置为软引用 SoftReference sr = new SoftReference(); if (sr.get() == null) { prev = rs.get(); } else { prev = new Browser(); sr = new SoftReference(prev); } ​​

• 软引用可以和一个引用队列(ReferenceQueue) 联合使用，如果软引用的对象被垃圾回收器回收，虚拟机会把这个软引用加入到与之关联的引用 队列中。

弱引用

• 它与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用 的对象，不管当前内存空间足够与否，都会回收它的内存。
• JDK1.2之后，提供了WeakReference 类来实现弱引用
• 示例

import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.util.LinkedList;

public class ReferenceTest {

    private static ReferenceQueue<VeryBig> rq = new ReferenceQueue<>();

    public static void checkQueue() {
        Reference<? extends VeryBig> ref = null;
        while ((ref = rq.poll()) != null) {
            if (ref != null) {
                System.out.println("In queue:" + ((VeryBigWeakReference) (ref)).id);
            }
        }
    }

    public static void main(String[] args) {
        int size = 3;
        LinkedList<WeakReference<VeryBig>> weakList = new LinkedList<>();
        for (int i = 0; i < size; i++) {
            weakList.add(new VeryBigWeakReference(new VeryBig("Weak " + i), rq));
            System.out.println("Just created weak: " + weakList.getLast());
        }
        System.gc();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        checkQueue();
    }

}

class VeryBig {

    public String id;
    /**
     * 占用空间,让线程进行回收
     */
    byte[] b = new byte[2 * 1024];

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

    @Override
    protected void finalize() {
        System.out.println("Finalizing VeryBig " + id);
    }
}

class VeryBigWeakReference extends WeakReference<VeryBig> {

    public String id;

    public VeryBigWeakReference(VeryBig big, ReferenceQueue<VeryBig> rq) {
        super(big, rq);
        this.id = big.id;
    }

    @Override
    protected void finalize() {
        System.out.println("Finalizing VeryBigWeakReference " + id);
    }
}

• 输出结果

Just created weak: cn.edu.cqvie.gc.VeryBigWeakReference@5451c3a8
Just created weak: cn.edu.cqvie.gc.VeryBigWeakReference@2626b418
Just created weak: cn.edu.cqvie.gc.VeryBigWeakReference@5a07e868
Finalizing VeryBig Weak 2
Finalizing VeryBig Weak 1
Finalizing VeryBig Weak 0
In queue:Weak 0
In queue:Weak 1
In queue:Weak 2

虚引用

• 虚引用称为幽灵引用或幻影引用。它是最弱的引用关系，一个独享是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来获取对象 实例。为一个对象设置虚应用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知。在JDK1.2后，提供了PhantomReference来实现虚引用。

四种引用的区别

引用类型	GC回收时间	用途	生存时间
强引用	never	对象的一般状态	JVM停止运行时
软引用	内存不足	对象缓存	内存足时终止
弱引用	GC时	对象缓存	GC后终止
虚引用	unknow	unknow	unknow

八、其它问题

finalize() 方法最终判断对象是否存活

在进行可达性分析中不可达的独享，也并非 “非死不可 ”的，这个时候他们将暂时处于 “即将回收”状态，如果要正真的被回收，至少需要再经历一次标记过程。

1. 第一次标记并且进行筛选
   筛选的条件是此对象是否有必要执行finalize()方法。
   假如对象没有覆盖finalize()方法，对象直接被回收 。
2. 第二次标
   如果对象覆盖了 finalize() 方法， finalize方法是对象被回收之前的最后一次存活的机会，如果要实现自我拯救，只需要重新与引用链上的任何一个对象建立关联即可，譬如把自己赋值给某个类变量或者对象的成员变量，那在第二次标记的时候就会将它移出“即将回收”的集合。如何对象这个时候还没有逃脱，那么对象将被回收。
   注意：对象的 finalize() 方法只会被执行一次，也就是说通过调用 finalize() 方法自我救命的机会就只有一次。

代码实例：

/**
 * 此代码演示了两点：
 * 1.对象可以在被GC时自我拯救。
 * 2.这种自救的机会只有一次，因为一个对象的finalize()方法最多只会被系统自动调用一次
 */
public class FinalizeEscapeGC {

    public static FinalizeEscapeGC SAVE_HOOK = null;

    public void isAlive() {
        System.out.println("yes, i am still alive :)");
    }

    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        System.out.println("finalize method executed!");
        FinalizeEscapeGC.SAVE_HOOK = this;
    }

    public static void main(String[] args) throws Throwable {
        SAVE_HOOK = new FinalizeEscapeGC(); //对象第一次成功拯救自己
        SAVE_HOOK = null;
        System.gc(); // 因为Finalizer方法优先级很低，暂停0.5秒，以等待它
        Thread.sleep(500);
        if (SAVE_HOOK != null) {
            SAVE_HOOK.isAlive();
        } else {
            System.out.println("no, i am dead :(");
        }
        //下面这段代码与上面的完全相同，但是这次自救却失败了
        SAVE_HOOK = null;
        System.gc();
        // 因为Finalizer方法优先级很低，暂停0.5秒，以等待它
        Thread.sleep(500);
        if (SAVE_HOOK != null) {
            SAVE_HOOK.isAlive();
        } else {
            System.out.println("no, i am dead :(");
        }
    }
}

输出结果：

finalize method executed!
yes, i am still alive :)
no, i am dead :(

如何判断一个类是一个无用的类？

方法区主要回收的是无用的类，那么如何判断一个类是无用的类呢？

类需要同时满足下面三个条件才能算是**“无用的类”**：

• 该类的所有实例都已经被回收，也就是说 Java 堆中不存在该类的任何实例。
• 加载该类的 ClassLoader 已经被回收（默认情况下，类加载后不会被主动卸载）。
• 该类对应的 java.lang.Class 对象没有在任何地方被引用，无法在任何地方通过反射访问该类的方法。

参考资料

1. 《深入理解 Java 虚拟机》 第三版 周志明
2. 《Java 虚拟机规范（Java SE 8 版）》 爱飞翔 周志明 等译