4.本地方法接口,5执行引擎,6垃圾回收

4.本地方法接口

4.1什么是本地方法

一个 Native Method 就是一个 java 调用非 java 代码的接口，一个

Native Method 是这样一个 java 方法：该方法的底层实现由非 Java 语言实现，

比如 C。这个特征并非 java 特有，很多其他的编程语言都有这一机制

在定义一个 native method 时，并不提供实现体（有些像定义一个 Java

interface），因为其实现体是由非 java 语言在外面实现的。

关键字 native 可以与其他所有的 java 标识符连用，但是 abstract 除外。

4.2 为什么要使用 Native Method

Java 使用起来非常方便，然而有些层次的任务用 java 实现起来不容易，或者我

们对程序的效率很在意时，问题就来了.

1.与 java 环境外交互：

有时 java 应用需要与 java 外面的环境交互，这是本地方法存在的主要原因。 你

可以想想 java 需要与一些底层系统，如擦偶偶系统或某些硬件交换信息时的情

况。本地方法正式这样的一种交流机制：它为我们提供了一个非常简洁的接口，

而且我们无需去了解 java 应用之外的繁琐细节。

2.与操作系统交互（比如线程最后要回归于操作系统线程）

JVM 支持着 java 语言本身和运行库，它是 java 程序赖以生存的平台，它由一个

解释器（解释字节码）和一些连接到本地代码的库组成。然而不管怎样，它毕竟

不是一个完整的系统，它经常依赖于一些底层系统的支持。这些底层系统常常是

强大的操作系统。通过使用本地方法，我们得以用 java 实现了 jre 的与底层系统

的交互，甚至 jvm 的一些部分就是用 C 写的。还有，如果我们要使用一些 java

语言本身没有提供封装的操作系统特性时，我们也需要使用本地方法。

3.Sun’s Java

Sun 的解释器是用 C 实现的，这使得它能像一些普通的 C 一样与外部交互。jre

大部分是用 java 实现的，它也通过一些本地方法与外界交互。例如：类

java.lang.Thread 的 setPriority()方法是用 Java 实现的，但是它实现调用的事

该类里的本地方法 setPriority0（）。这个本地方法是用 C 实现的，并被植入 JVM

内 部 ， 在 Windows 95 的 平 台 上 ， 这 个 本 地 方 法 最 终 将 调 用 Win32

setPriority()API。这是一个本地方法的具体实现由 JVM 直接提供，更多的情况

是本地方法由外部的动态链接库（external dynamic link library）提供，然后被 JVM 调用。

5.执行引擎

5.1概述

1.执行引擎是 Java 虚拟机核心的组成部分之一。

2.JVM 的主要任务是负责装载字节码到其内部，但字节码并不能够直接运行在

操作系统之上，因为字节码指令并非等价于本地机器指令，它内部包含的仅仅只

是一些能够被 JVM 所识别的字节码指令、符号表，以及其他辅助信息。

3.那么，如果想要让一个 Java 程序运行起来，执行引擎（Execution Engine）

的任务就是将字节码指令解释/编译为对应平台上的本地机器指令才可以。简单

来说，JVM 中的执行引擎充当了将高级语言翻译为机器语言的译者。

注意区分概念:

1.前端编译：从 Java 程序员-字节码文件的这个过程叫前端编译.

2.后端编译:(执行引擎这里有两种行为：一种是解释执行，一种是编译执行)

5.2什么是解释器?什么是JIT编译器?

解释器😗*：**当 Java 虚拟机启动时会根据预定义的规范对字节码采用逐行解释的方

式执行，将每条字节码文件中的内容“翻译”为对应平台的本地机器指令执行。

JIT(Just In TIme Compiler)编译器:

就是虚拟机将源代码一次性直接编译

成和本地机器平台相关的机器语言，但并不是马上执行。

5.3为什么Java是半编译半解释型语言?

JVM 设计者们的初衷仅仅只是单纯地为了满足 Java 程序实现跨平台特性，因此

避免采用静态编译的方式由高级语言直接生成本地机器指令，从而诞生了实现解

释器在运行时采用逐行解释字节码执行程序的想法。

解释器真正意义上所承担的角色就是一个运行时“翻译者”，将字节码文件中的

内容“翻译”为对应平台的本地机器指令执行,执行效率低。

JIT 编译器将字节码翻译成本地代码后，就可以做一个缓存操作，存储在方法区

的 JIT 代码缓存中（执行效率更高了）。

是否需要启动 JIT 编译器将字节码直接编译为对应平台的本地机器指令，则需要

根据代码被调用执行的频率而定。

JIT 编译器在运行时会针对那些频繁被调用的“热点代码”做出深度优化，将其

直接编译为对应平台的本地机器指令，以此提升 Java 程序的执行性能。

一个被多次调用的方法，或者是一-个方法体内部循环次数较多的循环体都可以

被称之为“热点代码”。

目前 HotSpot VM 所采用的热点探测方式是基于计数器的热点探测。

JIT编译器执行效率高为什么还需要解释器?

1.当程序启动后，解释器可以马上发挥作用，响应速度快，省去编译的时间，立

即执行。

2.编译器要想发挥作用，把代码编译成本地代码，需要一定的执行时间，但编译为本地代码后，执行效率高。就需要采用解释器与即时编译器并存的架构来换取

一个平衡点。

6.垃圾回收

6.1垃圾回收概述

6.1.1概述

1.Java 和 C++语言的区别，就在于垃圾收集技术和内存动态分配上，C++语

言没有垃圾收集技术，需要程序员手动的收集。

2…关于垃圾收集有三个经典问题：

​ 哪些内存需要回收？

​ 什么时候回收？

​ 如何回收？

6.1.2什么是垃圾?

垃圾是指在运行程序中没有任何指针指向的对象，这个对象就是需要被回收的垃

圾。

如果不及时对内存中的垃圾进行清理，那么，这些垃圾对象所占的内存空间会一

直保留到应用程序结束，被保留的空间无法被其他对象使用。甚至可能导致内存

溢出。

6.1.3为什么需要GC?

1.对于高级语言来说，一个基本认知是如果不进行垃圾回收，内存迟早都会

被消耗完，因为不断地分配内存空间而不进行回收，就好像不停地生产生活垃圾

而从来不打扫一样。

2.除了释放没用的对象，垃圾回收也可以清除内存里的记录碎片。碎片整理

将所占用的堆内存移到堆的一端，以便 JVM 将整理出的内存分配给新的对象。

3.随着应用程序所应付的业务越来越庞大、复杂，用户越来越多，没有 GC

就不能保证应用程序的正常进行。

6.1.4早期垃圾回收

在早期的 C/C++时代，垃圾回收基本上是手工进行的。开发人员可以使用 new

关键字进行内存申请，并使用 delete 关键字进行内存释放。

6.1.5Java垃圾回收机制

6.1.5.1自动内存管理

自动内存管理的优点

自动内存管理，无需开发人员手动参与内存的分配与回收，这样降低内存泄漏和

内存溢出的风险.

自动内存管理机制，将程序员从繁重的内存管理中释放出来，可以更专心地专注

于业务开发.

6.1.5.2关于自动内存管理的担忧:

1.对于 Java 开发人员而言，自动内存管理就像是一个黑匣子，如果过度依赖于

“自动”，那么这将会是一场灾难，最严重的就会弱化 Java 开发人员在程序出

现内存溢出时定位问题和解决问题的能力。

2.此时，了解 JVM 的自动内存分配和内存回收原理就显得非常重要，只有在真

正了解 JVM 是如何管理内存后，我们才能够在遇见 OutofMemoryError 时，

快速地根据错误异常日志定位问题和解决问题

3.当需要排查各种内存溢出、内存泄漏问题时，当垃圾收集成为系统达到更高并

发量的瓶颈时，我们就必须对这些“自动化”的技术实施必要的监控和调节。

6.1.5.3应该关心那些区域的回收?

垃圾收集器可以对年轻代回收，也可以对老年代回收，甚至是全栈和方法区的回

收，其中，Java 堆是垃圾收集器的工作重点

从次数上讲：

频繁收集 Young 区

较少收集 Old 区

基本不收集元空间(方法区)

6.2垃圾回收相关算法

6.2.1垃圾标记阶段算法

6.2.1.1标记阶段的目的

垃圾标记阶段:主要为了判断对象是否存活

1.在堆里存放着几乎所有的 Java 对象实例，在 GC 执行垃圾回收之前，首先需

要区分出内存中哪些是存活对象，哪些是已经死亡的对象。只有被标记为己经死

亡的对象，GC 才会在执行垃圾回收时，释放掉其所占用的内存空间，因此这个

过程我们可以称为垃圾标记阶段。

2.那么在 JVM 中究竟是如何标记一个死亡对象呢？简单来说，当一个对象已经

不再被任何的存活对象继续引用时，就可以宣判为已经死亡。

3.判断对象存活一般有两种方式：引用计数算法和可达性分析算法。

6.2.1.2引用计数算法

1.引用计数算法（Reference Counting）比较简单，对每个对象保存一个整型

的引用计数器属性。用于记录对象被引用的情况。

2.对于一个对象 A，只要有任何一个对象引用了 A，则 A 的引用计数器就加 1；

当引用失效时，引用计数器就减 1。只要对象 A 的引用计数器的值为 0，即表示

对象 A 不可能再被使用，可进行回收。

3.优点：实现简单，垃圾对象便于辨识；判定效率高，回收没有延迟性。

4.缺点：

1.它需要单独的字段存储计数器，这样的做法增加了存储空间的开销。

2.每次赋值都需要更新计数器，伴随着加法和减法操作，这增加了时间开销。

3.引用计数器有一个严重的问题，即无法处理循环引用的情况。这是一条致命

缺陷，导致在.Java 的垃圾回收器中没有使用这类算法。

6.2.1.3可达性分析算法

可达性分析算法:也可称为根搜索算法(追踪性垃圾收集)

1.相对于引用计数算法而言，可达性分析算法不仅同样具备实现简单和执行高效

等特点，更重要的是该算法可以有效地解决在引用计数算法中循环引用的问题，

防止内存泄漏的发生。

2.相较于引用计数算法，这里的可达性分析就是 Java、C#选择的。这种类型的

垃圾收集通常也叫作追踪性垃圾收集（Tracing Garbage Collection）

可达性分析实现思路

所谓"GCRoots”根集合就是一组必须活跃的引用

1.可达性分析算法是以根对象集合（GCRoots）为起始点，按照从上至下的方式

搜索被根对象集合所连接的目标对象是否可达。

2.使用可达性分析算法后，内存中的存活对象都会被根对象集合直接或间接连接

着，搜索所走过的路径称为引用链（Reference Chain）

3.如果目标对象没有任何引用链相连，则是不可达的，就意味着该对象己经死亡，

可以标记为垃圾对象。

4.在可达性分析算法中，只有能够被根对象集合直接或者间接连接的对象才是存

活对象。

GC Roots可以是哪些元素?

1.虚拟机栈中引用的对象

比如：各个线程被调用的方法中使用到的参数、局部变量等。

2.本地方法栈内 JNI（通常说的本地方法）引用的对象

3.方法区中类静态属性引用的对象

比如：Java 类的引用类型静态变量

4.方法区中常量引用的对象

比如：字符串常量池（StringTable）里的引用

5.所有被同步锁 synchronized 持有的对象

6.Java 虚拟机内部的引用。

基 本 数 据 类 型 对 应 的 Class 对 象 ， 一 些 常 驻 的 异 常 对 象 （ 如 ：

NullPointerException、OutofMemoryError），系统类加载器。

总结

1.简单一句话就是，除了堆空间的周边，比如：虚拟机栈、本地方法栈、方法区、

字符串常量池等地方对堆空间进行引用的，都可以作为 GC Roots 进行可达性分

析。

2.除了这些固定的 GC Roots 集合以外，根据用户所选用的垃圾收集器以及当前

回收的内存区域不同，还可以有其他对象“临时性”地加入，共同构成完整 GC

Roots 集合。比如：分代收集和局部回收。

由于 Root 采用栈方式存放变量和指针，所以如果一个指针，它保存了堆内存里

面的对象，但是自己又不存放在堆内存里面，那它就是一个 Root。

注意

如果要使用可达性分析算法来判断内存是否可回收，那么分析工作必须在一个能

保障一致性的快照中进行。这点不满足的话分析结果的准确性就无法保证。

这点也是导致 GC 进行时必须“Stop The World”的一个重要原因。即使是号

称（几乎）不会发生停顿的 CMS 收集器中，枚举根节点时也是必须要停顿的。

6.2.1.4对象的finalization机制

finalize()方法机制

对象销毁前的回调函数：finalize()；

Java 语言提供了对象终止（finalization）机制来允许开发人员提供对象被销毁

之前的自定义处理逻辑。

当垃圾回收器发现没有引用指向一个对象，即：垃圾回收此对象之前，总会先调

用这个对象的 finalize()方法。finalize() 方法允许在子类中被重写，用于在对象被回收时进行资源释放。通常

在这个方法中进行一些资源释放和清理的工作，比如关闭文件、套接字和数据库

连接等。

Object 类中 finalize() 源码

protected void finalize() throws Throwable { }

永远不要主动调用某个对象的 finalize()方法，应该交给垃圾回收机制调用。理

由包括下面三点：

1.在 finalize()时可能会导致对象复活。

2.finalize()方法的执行时间是没有保障的，它完全由 GC 线程决定，极端情况下，

若不发生 GC，则 finalize()方法将没有执行机会。

3.一个糟糕的 finalize()会严重影响 GC 的性能。比如 finalize 是个死循环。

6.2.1.5 生存还是死亡?

由于 finalize()方法的存在，虚拟机中的对象一般处于三种可能的状态。

如果从所有的根节点都无法访问到某个对象，说明对象己经不再使用了。一般来

说，此对象需要被回收。但事实上，也并非是“非死不可”的，这时候它们暂时

处于“缓刑”阶段。一个无法触及的对象有可能在某一个条件下“复活”自己，

如果这样，那么对它立即进行回收就是不合理的。为此，定义虚拟机中的对象可

能的三种状态。如下：

**可触及的：**从根节点开始，可以到达这个对象。

**可复活的：**对象的所有引用都被释放，但是对象有可能在 finalize()中复活。

**不可触及的：**对象的 finalize()被调用，并且没有复活，那么就会进入不可触及

状态。不可触及的对象不可能被复活，因为 finalize()只会被调用一次。

以上 3 种状态中，是由于 finalize()方法的存在，进行的区分。只有在对象不可

触及时才可以被回收。

具体过程

判定一个对象 objA 是否可回收，至少要经历两次标记过程：

1.如果对象 objA 到 GC Roots 没有引用链，则进行第一次标记。

2.进行筛选，判断此对象是否有必要执行 finalize()方法

如果对象 objA 没有重写 finalize()方法，或者 finalize()方法已经被虚拟机

调用过，则虚拟机视为“没有必要执行”，objA 被判定为不可触及的。

如果对象 objA 重写了 finalize()方法，且还未执行过，那么 objA 会被插

入到 F-Queue 队列中，由一个虚拟机自动创建的、低优先级的 Finalizer 线程触

发其 finalize()方法执行。

finalize()方法是对象逃脱死亡的最后机会，稍后 GC 会对 F-Queue 队列

中的对象进行第二次标记。如果 objA 在 finalize()方法中与引用链上的任何一个

对象建立了联系，那么在第二次标记时，objA 会被移出“即将回收”集合。之

后，对象会再次出现没有引用存在的情况。在这个情况下，finalize()方法不会被

再次调用，对象会直接变成不可触及的状态，也就是说，一个对象的 finalize()

方法只会被调用一次。

第一次自救成功，但由于 finalize() 方法只会执行一次，所以第二次自救失败。

6.2.2垃圾回收阶段算法

当成功区分出内存中存活对象和死亡对象后，GC 接下来的任务就是执行垃

圾回收，释放掉无用对象所占用的内存空间，以便有足够的可用内存空间为新对

象分配内存。目前在 JVM 中比较常见的三种垃圾收集算法是:

标记-清除算法（Mark-Sweep）

复制算法（Copying）

标记-压缩算法（Mark-Compact）

6.2.2.1标记清楚算法

当堆中的有效内存空间（available memory）被耗尽的时候，就会停止整个程序（STW），然后进行两项工

-标记

-清除

标记：(可达性分析算法) Collector 从引用根节点开始遍历，标记所有被引用的对象。一般是在对象的 Header 中记录为可达对象。

清除： 有一个空闲列表,记录垃圾位置,有新对象时需要加载时,覆盖垃圾位置

特点:简单;这种方式清理出来的空闲内存是不连续的，产生内碎片，需要维护一个空闲列表。（空闲列表-记录垃圾对象地址）。

6.2.2.2复制算法

为了解决标记-清除算法在效率方面的缺陷，它将可用内存划分为大小相等的两块，有一块是空闲的.
在垃圾回收时将把没有回收到的对象,复制到空闲内存区域，之清除原来的区域，交换两个内存的角色. (幸存者1-幸存者2)

特点:

内存需要两块,对象发生赋值,大量对象效率低.

复制算法的应用场景

如果系统中的垃圾对象很多，复制算法需要复制的存活对象数量并不会太大，效率较高 ,老年代大量的对象存活，那么复制的对象将会有很多，效率会很低 在新生代， 对常规应用的垃圾回收，一次通常可以回收 70% - 99% 的内存空间。 回收性价比很高。所以现在的商业虚拟机都是用这种收集算法回收新生代。

6.2.2.3标记压缩算法

老年代大部分是存活对象,复制的成本高,基于此特性，需要使用其他的算法。

标记压缩算法的执行过程

标记

压缩:将存活的对象整理到内存的一端，按顺序排放。之后，清理边界外所有的空间,不会产生内存碎片
特点:效率低

标清和标压区别:标记-清除算法是一种非移动式的回收算法（空闲列表记录位置），标记-压缩是移动式的。是否移动回收后的存活对象是一项优缺点并存的风险决策。

标记-压缩算法的优缺点

优点

• 消除了标清算法内存区域分散的缺点
• 我们需要给新对象分配内存时，JVM 只需要持有一个内存的起始地址即可。
• 消除了复制算法内存减半的代价

缺点

• 从效率上来说，标记-整理算法效率要低于复制算法。
• 移动对象的同时，如果对象被其他对象引用，则还需要调整引用的地址
• 移动过程中，需要全程暂停用户应用程序。即：STW

6.2.2.5分代收集算法

因为不同的对象的生命周期是不一样的。因此，不同生命周期的对象可以采取不同的收集方式，以便提高回收效率。
一般是把Java 堆分为新生代和老年代，就可以根据各个年代的特点使用不同的回收算法，以提高垃圾回收效率。

年轻代（Young Gen）

年轻代特点：区域相对老年代较小，对象生命周期短、存活率低，回收频繁。

这种情况复制算法的回收整理，速度是最快的。复制算法的效率只和当前存活对象大小有关，因此很适用于年轻代的回收。而复制算法内存利用率不高的问题，通过 hotspot 中的两个 survivor 的设计得到缓解。

老年代（Tenured Gen）

老年代特点：区域较大，对象生命周期长、存活率高，回收不及年轻代频繁。

一般是由标记- 清除或者是标记-清除与标记-整理的混合实现。

分代的思想被现有的虚拟机广泛使用。几乎所有的垃圾回收器都区分新生代和老年代。

6.2.2.6 增量收集算法和分区算法

对实时垃圾 收集算法的研究直接导致了增量收集（Incremental Collecting）算法的诞生。

增量收集算法基本思想

(让垃圾回收间断进行)

让垃圾收集线程和应用程序线程交替执行,直到垃圾收集完成。增量收集算法的基础仍是传统的标记-清除和复制算法。增量收集算法通过对线程间冲突的妥善处理，允许垃圾收集线程以分阶段的方式完成标记、清理或复制工作。

缺点

由于在垃圾回收过程中，间断性地还执行了应用程序代码，所以能减少系统的停顿时间。但是线程切换和上下文转换会使得垃圾回收的总体成本上升，造成系统吞吐量的下降

分区算法

在相同条件下，堆空间越大，一次 GC 时所需要的时间就越长，有关GC 产生的停顿也越长。为了控制 GC 产生的停顿时间，将一块大的内存区域分割成多个小块，根据目标的停顿时间，每次合理地回收若干个小区间,从而减少一次 GC 所产生的停顿。 分代算法将按照对象的生命周期长短划分,分区算法将堆空间划分成连续的不同小区间。每一个小区间都独立使用，独立回收。这种算法的好处是可以控制一次回收多少个小区间。

6.3垃圾回收相关概念

6.3.1内存溢出与内存泄漏

内存溢出(内存不够用了)

垃圾回收已经跟不上内存消耗的速度，否则不太容易出现 OOM 的情

况。

大多数情况下，GC 会进行各种年龄段的垃圾回收，实在不行了就放大招，来

一次独占式的 Full GC 操作，这时候会回收大量的内存，供应用程序继续使用。

Javadoc 中对 OutofMemoryError 的解释是，没有空闲内存，并且垃圾收集

器也无法提供更多内存。

内存泄漏

内存泄漏也称作“存储渗漏”。严格来说，只有对象不会再被程序用到了，但

是 GC 又不能回收他们的情况，才叫内存泄漏。

但实际情况很多时候一些不太好的实践（或疏忽）会导致对象的生命周期变得

很长甚至导致 OOM，也可以叫做宽泛意义上的“内存泄漏”。

单例模式

单例的生命周期和应用程序是一样长的，所以在单例程序中，如果持有对外部

对象的引用的话，那么这个外部对象是不能被回收的，则会导致内存泄漏的产生。

一些提供 close()的资源未关闭导致内存泄漏

数据库连接 dataSourse.getConnection()，网络连接 socket 和 io 连接必须

手动 close，否则是不能被回收的。

6.3.2Stop the World

Stop-the-World，简称 STW，指的是 GC 事件发生过程中，会产生应用程序的

停顿。停顿产生时整个应用程序线程都会被暂停，没有任何响应，有点像卡死的

感觉，这个停顿称为 STW。

可达性分析算法中枚举根节点（GC Roots）会导致所有 Java 执行线程停顿，为

什么需要停顿所有 Java 执行线程呢？

1.分析工作必须在一个能确保一致性的快照中进行

2.一致性指整个分析期间整个执行系统看起来像被冻结在某个时间点上

3.如果出现分析过程中对象引用关系还在不断变化，则分析结果的准确性无法保

证

4.被 STW 中断的应用程序线程会在完成 GC 之后恢复，我们需要减少 STW 的发生。

5.STW 事件和采用哪款 GC 无关，所有的 GC 都有这个事件。

6.越优秀，回收效率越来越高，尽可能地缩短了暂停时间。STW 是 JVM 在后台自动发起和自动完成的。在用户不可见的情况下，把用户正常的工作线程全部停掉。

6.3.4对象引用

强引用（Strong Reference）

软引用（Soft Reference）

弱引用（Weak Reference）

虚引用（Phantom Reference）

**强引用（StrongReference）：**最传统的“引用”的定义，是指在程序代码之

中普遍存在的引用赋值，即类似“object obj=new Object()”这种引用关系。

无论任何情况下，只要强引用关系还存在，垃圾收集器就永远不会回收掉被引用

的对象。宁可报 OOM，也不会 GC 强引用

软引用（SoftReference）：内存不足即回收,在系统将要发生内存溢出之前，将会把这些对象列

入回收范围之中进行第二次回收。如果这次回收后还没有足够的内存，才会抛出

内存溢出异常。

弱引用（WeakReference）：发现即回收,被弱引用关联的对象只能生存到下一次垃圾收集

之前。当垃圾收集器工作时，无论内存空间是否足够，都会回收掉被弱引用关联

的对象。

**虚引用（PhantomReference）：**一个对象是否有虚引用的存在，完全不会对

其生存时间构成影响，也无法通过虚引用来获得一个对象的实例。为一个对象设

置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知。

// 声明强引用

Object obj = new Object();

// 声明引用队列

ReferenceQueue phantomQueue = new ReferenceQueue();

// 声明虚引用（还需要传入引用队列）

PhantomReference sf = new PhantomReference<>(obj, phantomQueue);

软引用（Soft Reference）

弱引用（Weak Reference）

虚引用（Phantom Reference）

**强引用（StrongReference）：**最传统的“引用”的定义，是指在程序代码之

中普遍存在的引用赋值，即类似“object obj=new Object()”这种引用关系。

无论任何情况下，只要强引用关系还存在，垃圾收集器就永远不会回收掉被引用

的对象。宁可报 OOM，也不会 GC 强引用

软引用（SoftReference）：内存不足即回收,在系统将要发生内存溢出之前，将会把这些对象列

入回收范围之中进行第二次回收。如果这次回收后还没有足够的内存，才会抛出

内存溢出异常。

弱引用（WeakReference）：发现即回收,被弱引用关联的对象只能生存到下一次垃圾收集

之前。当垃圾收集器工作时，无论内存空间是否足够，都会回收掉被弱引用关联

的对象。

**虚引用（PhantomReference）：**一个对象是否有虚引用的存在，完全不会对

其生存时间构成影响，也无法通过虚引用来获得一个对象的实例。为一个对象设

置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知。

// 声明强引用

Object obj = new Object();

// 声明引用队列

ReferenceQueue phantomQueue = new ReferenceQueue();

// 声明虚引用（还需要传入引用队列）

PhantomReference sf = new PhantomReference<>(obj, phantomQueue);

obj = null;