一、前言

为什么要学JVM?
学习JVM是开发Java应用程序必不可少的一部分，因为JVM是Java平台的核心。以下是为什么要学习JVM的几个原因：

1. 跨平台性：JVM可以在不同的系统上运行Java代码，使Java应用程序具备了可移植性和跨平台性。

2. 内存管理：JVM的内存管理机制自动回收不再使用的内存，保证了Java程序的稳定性和可靠性。

3. 性能优化：通过学习JVM的内部机制和优化技术，可以提高Java程序的性能。

4. 调试技能：学习JVM可以帮助开发人员更好地理解Java程序的运行机制，从而调试和排查程序中的问题。

5. 应用监控：JVM自带的监控工具可以提供Java应用程序的性能数据，帮助开发人员优化程序和调整系统参数。

综上所述，学习JVM是Java开发人员必备的基础技能，有助于提高程序开发和优化能力，从而构建高效、稳定的Java应用程序。

其实对于一个还没毕业的学生来讲–就是为了面试。但也不是完全为了面试。所以本片文章则偏向于面试目的的学习。

二、JVM概述

JVM（Java Virtual Machine）是Java程序的运行环境，它是一个虚拟的计算机，可以在不同的平台上运行Java程序，实现了Java程序的跨平台性。JVM包括类加载器、解释器、即时编译器、垃圾收集器等组件。

1. 类加载器：类加载器负责将Java类文件加载到JVM中，Java程序在运行时会根据需要动态加载类文件。JVM中有三种类加载器，分别是Bootstap ClassLoader、Extension ClassLoader和System ClassLoader。

2. 解释器：解释器负责将Java字节码解释成机器可以执行的指令，实现了Java程序的跨平台性。Java程序在运行时不是直接运行源代码，而是将源代码编译成Java字节码（即.class文件），JVM中的解释器会将Java字节码解释成机器可以执行的指令。

3. 即时编译器：即时编译器（JIT，Just-In-Time Compiler）是JVM的一个重要组件，它可以将Java字节码编译成与特定硬件平台相关的本地代码，从而提高Java程序的执行效率。

4. 垃圾收集器：垃圾收集器是JVM的一个重要组件，它负责自动回收不再使用的Java对象的内存，从而避免了手动管理内存的麻烦。JVM中的垃圾收集器具有自动、周期性、无需干预等特点。

JVM还实现了Java程序的安全性和隔离性，可以对Java程序进行安全管理和控制，保证程序的安全性和可靠性。除了Java语言，JVM也支持其他语言，如Groovy、Scala、Kotlin等

三、内存模式

JVM（Java Virtual Machine）是Java程序的运行环境，它有自己的内存管理系统。在JVM中，内存分为几个部分，主要包括以下几种：

1. 堆（Heap）：堆是JVM中最大的一块内存，它被所有线程共享，用于存储对象实例。当一个对象被创建时，它被存储在堆中，并返回该对象的引用（reference）。

2. 栈（Stack）：栈是JVM中的一块线程私有内存，每个线程都有自己的栈。栈用于存储基本类型的变量和对象引用。当一个方法被调用时，该方法的参数和局部变量都被存储在该线程的栈中。当方法执行完毕后，它使用的栈空间被释放。

3. 方法区（Method Area）：方法区也是JVM中的一块共享内存，用于存储已经被加载的类的信息、常量、静态变量、即时编译器（JIT）编译后的代码等。

4. 本地方法栈（Native Method Stack）：本地方法栈与栈类似，但用于存储与本地方法（native methods）相关的数据。

JVM内存管理是自动的，也就是说，Java开发人员无需手动分配和管理内存。JVM会自动对内存进行回收和清理，从而使应用程序更加稳定和可靠。

3.1程序计数器

程序计数器（Program Counter Register）是JVM中的一块内存区域，用于存储正在执行的Java虚拟机字节码指令的地址。每个线程都有自己的程序计数器，以便于同时执行多个线程。每当线程执行一个新的Java虚拟机字节码指令时，程序计数器就会相应地更新当前线程正在执行的指令位置。程序计数器是JVM中最小的一块内存区域，它的大小通常是固定的，一般为4字节或8字节。

程序计数器的主要作用包括以下几个方面：

1. 它是线程私有的，确保线程之间的独立性，从而保证了多个线程之间的执行不会出现混乱。

2. 程序计数器保存当前线程所执行的Java虚拟机字节码指令的地址，可作为线程恢复的依据。

3. 在Java虚拟机中，程序计数器作为垃圾收集器的判断依据之一。如果程序计数器的值为0，则表示该线程目前没有执行任何Java虚拟机字节码指令，因此可以被垃圾收集器作为回收的对象。

4. 是记住下一条jvm指令的执行地址。在Java虚拟机中，由于线程切换导致上下文切换，程序计数器用于帮助线程恢复正在执行的位置，防止线程切换后需要重新从头开始执行，降低了线程切换的成本。

总之，程序计数器是JVM中非常重要的一部分，它可以保证线程之间的独立性，同时也是JVM实现其他高级特性的基础。它的作用就是记录当前线程在执行字节码时的位置，支持Java虚拟机的多线程编程和执行，并且不会内存溢出。

3.2虚拟机栈

虚拟机栈（Virtual Machine Stack）是Java虚拟机中一块内存区域，用于存储Java方法执行的信息。每当Java方法被调用时，JVM就会为该方法创建一个帧（Frame），并将该帧压入当前线程的虚拟机栈中。每个帧包含了该方法的局部变量表、操作数栈、动态链接、方法出口等信息。当方法执行完毕时，该帧被出栈，恢复原有帧的上下文环境。

概述：每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存。每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法。

虚拟机栈的主要作用包括以下几个方面：

1. 实现了Java方法的深度优先调用：虚拟机栈通过存储每个方法的帧确保方法的调用和返回按照预期的方式执行，从而实现了Java方法的深度优先调用。

2. 维护方法的上下文环境：每个帧包含了该方法的局部变量表、操作数栈、动态链接、方法出口等信息，虚拟机栈的作用就是在方法的调用和返回时维护该方法的上下文环境。

3. 帮助线程在方法执行过程中恢复现场：虚拟机栈记录了线程执行方法的顺序和方法的调用链，能够在方法执行出现异常或其他情况下，帮助线程在方法执行过程中恢复现场。

4. 线程私有的：每个线程都有自己的虚拟机栈，确保线程之间的独立性，避免线程之间的干扰。

总之，虚拟机栈是Java虚拟机非常重要的一部分，它保证了方法的调用和返回按照预期的方式执行，实现了Java方法的深度优先调用。虚拟机栈还通过存储每个方法的帧维护方法的上下文环境，支持线程在方法执行过程中恢复现场。虚拟机栈的大小是不固定的，它可以根据实际需要动态扩展或缩小。

3.3本地方法栈

本地方法栈（Native Method Stack）是JVM在执行本地方法时，为其分配的内存空间，用于存储本地方法执行的相关信息，包括本地方法的调用和返回状态、本地方法的参数和局部变量等。与Java虚拟机栈不同的是，本地方法栈不参与Java方法的调用，它是为在Java虚拟机之外执行的本地方法分配内存的。

本地方法栈是线程私有的，当一个线程调用本地方法时，JVM会为该线程创建一个本地方法栈。本地方法栈的大小可以通过JVM参数 -Xss 来指定，同Java虚拟机栈一样，本地方法栈也会防止线程堆栈溢出的问题。

需要注意的是，本地方法栈与本地方法库之间是有联系的，当JVM调用本地方法时，实际上是通过本地方法库加载本地方法并执行，而在执行过程中，本地方法栈中的相关信息也会传递给本地方法库。因此，在编写本地方法时，需要严格遵循本地方法调用的规范，避免出现不可预知的错误。

3.4堆

在Java虚拟机中，堆（Heap）是一个用于存储对象实例的运行时数据区域(new 的对象都会使用堆内存)。在整个Java程序的内存分配中，最大的一部分就是堆内存。堆内存是由垃圾回收器进行自动垃圾回收和释放的。这就使得开发人员无需手动管理内存的分配和释放，可以集中精力在应用程序的开发和实现上。

堆内存是由Java虚拟机在程序运行时动态分配的，也就是说，在程序运行时，堆内存的大小是可以变化的。堆内存通常被划分为“新生代”和“老年代”两个部分，其中“新生代”用于存放新创建的对象，而“老年代”用于存放已经存在一段时间的对象。

Java虚拟机的垃圾回收器通过标记清除（Mark and Sweep）或标记复制（Mark and Copy）等算法来进行垃圾回收。当对象不再被任何引用所指向时，垃圾回收器就会将其所占用的内存空间标记为可回收的，等待下一次垃圾回收时进行释放。

虽然Java程序可以自动进行内存管理，但是如果程序中存在内存泄漏、对象过多等问题，堆内存依旧会被耗尽，导致程序崩溃。因此，开发人员还应该考虑如何对程序的内存使用进行优化，减少不必要的对象创建和内存占用，以保证程序的稳定性和性能。

特点：

• 他是线程共享的。堆中的对象都需要考虑线程安全问题
• 有垃圾回收机制

3.4.1堆内存溢出

堆（Heap）内存溢出是指当程序需要向堆中分配内存时，堆内存无法满足要求而抛出内存溢出异常。通常情况下，堆内存溢出是由以下原因引起的：

1. 程序中创建了大量的对象- 如果程序中存在过多的对象，那么就会占用大量的堆内存空间。在此期间，内存占用的大小会超过指定的堆内存大小而导致内存溢出异常。

2. 长时间运行的Java进程- 如果程序在长时间运行的过程中，一直不释放对象所占用的内存，就有可能导致堆内存耗尽而抛出内存溢出异常。

3. 堆内存区域配置不当- 如果分配给堆内存区域的内存不够或者分配的大小小于程序的要求，就会出现内存溢出的情况。

在Java虚拟机中，当出现堆内存溢出时，Java虚拟机就会抛出OutOfMemoryError异常。通常来说，可以通过增加堆内存的容量或者优化程序的内存使用情况来避免内存溢出的问题。如果程序出现堆内存溢出的情况，在分析日志之后通常可以辨认出是否需要增加堆内存容量还是需要优化程序的内存使用情况。

3.4.2堆内存诊断

进行堆内存诊断通常需要使用一些工具来进行。下面介绍几种堆内存诊断方法：

1. 内存分析工具
   使用内存分析工具（例如Eclipse Memory Analyzer或VisualVM）可以生成Dump文件，然后对其进行分析、寻找问题所在。

2. 设置JVM参数
   通过设置JVM参数，可以收集并输出关于堆内存使用情况的日志信息。例如，设置JVM参数-XX:+HeapDumpOnOutOfMemoryError可以在出现内存溢出错误时自动记录一个heap dump文件。

3. 分析GC日志
   通过分析GC日志，可以了解更多有关Java虚拟机中的对象创建和垃圾回收的信息。可以使用GC日志分析工具（例如GCEasy）来帮助分析GC日志。

4. 手工排查代码
   手工排查代码是一种最基本的堆内存诊断方法。通过检查代码中有没有循环创建对象实例，重复执行的操作等，找出内存泄漏的原因。

5. 进行压力测试
   通过对程序进行压力测试，可以模拟程序在不同负载情况下的性能表现，发现程序运行过程中所使用的堆内存大小是否超出了预期。

总之，堆内存诊断需要多方面的考虑，结合不同方法得出的结果进行分析，才能快速定位问题并解决问题。
常用方法如下：

1. jps 工具
   查看当前系统中有哪些 java 进程
2. jmap 工具
   查看堆内存占用情况 jmap - heap 进程id
3. jconsole 工具
   图形界面的，多功能的监测工具，可以连续监测
4. jvisualvm工具
   使用jvisualvm可以查看堆内存使用情况、线程运行情况、方法的调用次数和执行时间等信息

3.5方法区

在Java虚拟机中，方法区（Method Area）又称为永久代（Permanent Generation），是用于存储类的元数据的区域，是堆内存的一部分，专门用来存储已加载的类、常量、静态变量、即时编译器编译后的代码等信息。方法区被所有线程共享，它的大小在启动时就已经确定，并且会在运行时动态调整。从JDK 8之后，Java虚拟机中的方法区被移除，被元数据区（MetaSpace）所取代。

Java虚拟机中的方法区（永久代）通常包括以下几个重要的部分：

1. 类的元数据信息：包括类的名称、属性和方法的特征和访问权限等信息。

2. 静态变量：由所有实例共享的数据，通常包括静态变量和常量。

3. 字符串常量池：Java虚拟机中的字符串常量池保存着字符串类型的常量值。

4. 即时编译器编译后的代码：即时编译器将Java代码编译成本地代码执行，这些编译后的代码也存放在方法区中。

在Java虚拟机的运行过程中，方法区的大小会动态调整以适应运行的需要。方法区内存的分配和垃圾回收都由Java虚拟机自行管理，并且不需要程序员显式地管理它。但是，如果方法区中存放的类或常量过多，也可能导致内存泄漏或堆内存溢出等问题。因此，在Java虚拟机中，通过调整方法区的大小和设置垃圾回收策略来管理方法区内存使用已变得尤为重要。
1.8和1.8之前的内存结构对比图：

3.5.1方法区内存溢出

在JVM中，方法区（也称为永久代）是存储类、方法、常量等元数据的地方。如果一个应用程序使用的是大量的类（例如，有许多大型框架和库），那么可能会导致方法区的内存使用量急剧增加。如果方法区的内存使用量超过了JVM为其分配的内存，就会发生方法区内存溢出。

下面列举了几种可能导致JVM中方法区内存溢出的场景：

1. 大规模地使用反射：反射是指在运行时动态地加载类或调用类中的方法。使用反射可能会导致大量的类加载和卸载，导致方法区内存使用量增加。如果应用程序中存在大量的反射操作，则可能会导致方法区内存溢出。

2. 大规模使用动态代理：动态代理是一种机制，通过代理来完成一些操作。在运行时生成代理对象以及相应的代码可能会导致大量的类加载和卸载，导致方法区内存使用量增加。

3. 大规模使用字符串常量：在Java中，字符串常量被维护在方法区中。如果应用程序中存在大量的字符串常量，且没有被垃圾回收，可能会导致方法区内存溢出。

4. 大规模使用大型框架和库：一些大型框架和库可能会带来大量的类、方法、常量等元数据。如果应用程序使用了过多的框架和库，可能会导致方法区内存溢出。

5. 代码动态生成：如果应用程序中存在动态生成代码的情况，例如使用Javassist等工具动态生成类，也可能导致方法区内存溢出。

方法区内存溢出的解决办法可能有以下几种：

1. 增加方法区的内存：可以通过修改JVM参数，增加方法区的最大内存限制。例如，在启动应用程序时添加以下参数：-XX:MaxPermSize=256m

2. 优化代码和库的使用：可以通过减少不必要的类、方法、常量等元数据的使用来降低方法区的内存使用量。

3. 使用新的垃圾回收器：一些新的垃圾回收器对方法区的内存使用效率更高。例如，JVM 7引入了G1垃圾回收器，可以更好地管理方法区内存。

3.5.2运行时常量池

Java虚拟机的运行时常量池是一种在运行时存储常量的表，Java 编译器将常量池数据存储在 .class 文件的常量池中，并且也可以动态的添加。它包含类和接口的常量池，每个类和接口都有独立的常量池。

运行时常量池中存储的是类或者接口的描述符、字段、方法、接口名称等等，也可以存储字面量，例如字符串，数字，布尔值等等。

在Java程序运行时，运行时常量池的数据会被加载到JVM的内存中，在内存中被放置在方法区（JVM被各个线程共享的内存区域）。这个过程是Java程序在执行过程中一次性装载的，而且是在程序启动时自动完成的。

使用运行时常量池的一个最大优点是其使用方便。开发人员可以简单地使用字面量，而无需创建新的String或数字对象，并且Java编译器会自动为常量创建常量表达式，从而使程序更加容易理解和可读。

但是在一些特定的情况下（比如字符串拼接等）会导致频繁的内存使用，影响性能。此时可以通过自动的JIT编译器的优化来缓解这种影响。

常量池，就是一张表，虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量
等信息
运行时常量池，常量池是 *.class 文件中的，当该类被加载，它的常量池信息就会放入运行时常量
池，并把里面的符号地址变为真实地址

3.5.3StringTable

StringTable是JVM中一种特殊类型的哈希表,为了提高字符串处理性能优化的一种手段，用于存储字符串对象的引用。StringTable是JVM内部实现的一种优化手段，它会对字符串进行自动去重。在这个表中，每个字符串对象只会有一个唯一的实例存在于内存中。具体实现方式是：当一个字符串创建时，如果StringTable中已有与之对应的字符串，就直接指向已有字符串的实例，否则，就新创建一个字符串，然后添加到StringTable中。由于每个字符串具有唯一的引用，JVM可以更容易地进行优化，并且减少内存的使用，同时提高程序的运行效率。

在JVM中，StringTable会存在于堆内存中，根据JVM的版本不同，StringTable可以使用不同的实现方式。在JDK8之前，StringTable的默认实现方式是固定大小的哈希表；JDK8之后，引入了叫做“红黑树”的新实现方式，以解决哈希表的性能问题。

需要注意的是，由于StringTable是在堆内存中占用空间的，而通常堆内存比较紧张，因此需要多方面考虑字符串的使用，避免不必要的字符串对象的产生，否则会导致内存的浪费和程序性能的下降。

StringTable特性：

1. StringTable在JVM启动时创建，并且一直存在于JVM中。

2. StringTable是一种线程安全的结构，多个线程可以同时访问它。

3. 当JVM加载一个新的类时，它会检查类文件中的常量池，并将其中的字符串添加到StringTable中。

4. 如果StringTable中已经存在相同散列码的字符串，则直接返回对该字符串的引用。

5. StringTable的大小可以通过命令行参数“-XX:StringTableSize”进行调整，默认大小为32768。

6. 在JVM中，String.intern()方法可以将一个字符串添加到StringTable中，如果该字符串在StringTable中已经存在，则返回一个对该字符串的引用。

总之，StringTable是JVM中管理字符串对象的重要机制之一。它实现了字符串的共享，避免了重复创建字符串对象，提高了程序的性能和内存利用率。

StringTable 垃圾回收
由于StringTable是一个固定大小的散列表，它不是一个动态数据结构。因此，JVM不会在StringTable中对字符串对象进行垃圾回收。StringTable中的字符串对象只能在没有对它们的引用时由垃圾回收器回收。

有时候，当应用程序使用大量字符串时，StringTable可能会导致堆内存的膨胀，因为StringTable会一直保存字符串对象的引用，即使这些字符串对象已经不再使用。在这种情况下，可以通过手动调整StringTable的大小来缓解这个问题。您可以使用JVM参数-XX:StringTableSize=来增加或减少StringTable的大小。

总之，JVM不会对StringTable中的字符串对象进行垃圾回收。StringTable中的字符串对象只有在没有对它们的引用时才能被垃圾回收器回收。如果StringTable导致堆内存膨胀，可以通过手动调整它的大小来缓解这个问题。

StringTable 性能调优
StringTable是用于存储字符串常量池中字符串对象的散列表。它允许多个字符串引用相同的字符串对象，使得这些对象只分配一次且在整个JVM中共享，从而提高了内存使用效率。下面是一些StringTable的性能调优技巧：

1. 增加StringTable大小： 默认情况下，StringTable的最大大小为1009，这可能太小，导致哈希冲突。可以使用JVM参数"-XX:StringTableSize=number" 来增加StringTable的大小，从而减少哈希冲突的概率。

2. 禁用StringTable： 如果应用程序中没有大量字符串比较，禁用StringTable可能会提高性能。可以使用JVM参数 “-XX:-UseStringTable” 来禁用StringTable。

3. 禁用字符串重复： 这个选项允许JVM删除具有相同内容的字符串，从而减少内存使用。使用"-XX:+OptimizeStringConcat" 禁用字符串重复操作。

4. 监控StringTable性能： 可以使用JVM参数 “-XX:+PrintStringTableStatistics” 来监视StringTable性能，以及散列表的大小、聚集度等信息。

5. 使用StringBuilder而不是String拼接：String的拼接操作可以通过StringBuilder来优化，这样可以更少地创建临时字符串，减少StringTable中字符串的数量，从而减小了字符串常量池的大小。

总之，在JVM中，StringTable是一个非常重要的机制，对于性能方面也有很大的影响。通过选择合适的大小、禁用StringTable等优化手段，可以提高性能并减少内存使用。但是需要注意，这些调优方法需要根据具体应用场景进行选择。

四、直接内存

JVM直接内存（Direct Memory）是一种直接分配在操作系统的地址空间中的内存（也就是系统内存），不受JVM堆大小的限制。与JVM堆内存不同，JVM直接内存是由JVM外部的内存管理库分配的，并由JVM直接访问，而不是通过JVM堆内存进行中介，这样可以在一定程度上提高Java应用程序的性能和效率。

在Java应用程序中，通常使用NIO库实现直接内存的分配和使用。通过使用ByteBuffer或MappedByteBuffer这样的Buffer类，可以直接从JVM里分配一块直接内存，还可以使用DirectByteBuffer类来操作这些直接内存，这些特殊的Buffer类也可以通过JNI调用C或C++程序来操作直接内存。

与JVM堆内存不同，JVM直接内存的分配和回收通常比较复杂，需要开发人员手动管理，否则可能会导致内存泄漏等问题。Java 9引入了一种新的API，jdk.internal.misc.Unsafe，通过这个API实现对JVM直接内存的显式分配和释放，同时也提供了更加高效的内存控制能力。

总之，JVM直接内存是一种直接分配在操作系统地址空间中的内存，主要用于提高Java应用程序的性能和效率。虽然使用JVM直接内存可以带来很多好处，但开发人员需要手动管理JVM直接内存的分配和回收，才能保证程序的稳定性和高效性。

4.1分配回收原理

JVM的直接内存是指使用NIO库进行I/O操作时，调用的java.nio.ByteBuffer类中的allocateDirect()方法所分配出的内存空间。直接内存的分配和回收由操作系统负责。

在Java中，有两种内存管理机制，一种是JVM中的堆内存管理，另一种是直接内存管理。直接内存管理不属于JVM内存，而是由操作系统管理，使用Java的NIO库时会经常使用，它与堆内存不同的地方在于分配的内存会被直接分配到物理内存中而不是进程的堆中。

直接内存分配时，可以通过ByteBuffer类的allocateDirect()方法来分配所需大小的内存块。回收时，由于直接内存是由操作系统来管理的，所以JVM是无法直接回收的，需要通过调用DirectByteBuffer.cleaner()方法来触发垃圾回收。

具体来说，每当JVM中的直接内存对象不再被程序使用时，会将其加入到DirectByteBuffer的ReferenceQueue队列中，然后在后台通过Registries类中的register方法来实现垃圾回收。当需要手动回收时，可以使用System.gc()方法或者在代码中显式调用ReferenceQueue对象的poll()方法来执行回收操作。

需要注意的是，直接内存的分配比较耗资源，建议在使用时按需分配，并且需要手动回收。

概括：

• 使用了 Unsafe 对象完成直接内存的分配回收，并且回收需要主动调用 freeMemory 方法
• ByteBuffer 的实现类内部，使用了 Cleaner （虚引用）来监测 ByteBuffer 对象，一旦ByteBuffer 对象被垃圾回收，那么就会由 ReferenceHandler 线程通过 Cleaner 的 clean 方法调用 freeMemory 来释放直接内存

五、垃圾回收

JVM（Java Virtual Machine）是Java语言的核心，它是一个运行Java字节码的虚拟机。JVM中垃圾回收是Java程序中的重要概念，在Java中使用垃圾回收机制可以提高内存使用效率和程序性能，降低程序出错几率。

垃圾回收是指自动扫描动态分配的内存区域，找出那些已经不再使用的对象并且将它们释放，以便供将来的内存分配。JVM中垃圾回收的实现主要依赖于下面四个算法：

1. 标记-清除算法
   这是最基本的算法，它的核心思路：先标记出所有需要回收的对象，然后统一清除。这种方法的缺点显而易见，清理后会产生大量不连续的碎片化空间，如果内存碎片太多，可能会导致以后需要分配大对象时空间不足。解决方法是进行内存空间整理，将存活的对象往一端移动然后直接清理掉端部的垃圾。

2. 复制算法
   复制算法的思路：将内存分为大小相等的两个区域，每次只使用其中的一部分，当这部分内存用完了，就将还活着的对象全部复制到另一部分的未使用区域中，并将原来的区域全部清空。这种算法每次可以清理一半的垃圾，但是需要对内存空间进行大量的复制，如果存活对象太多，会导致效率降低。

3. 标记-整理算法
   标记-整理算法的思路：标记出需要回收的对象，然后死亡对象的空间全部向一端移动，然后直接清理掉端部的垃圾，这样可以解决标记-清除算法产生碎片的问题。

4. 分代收集算法
   分代收集算法的思路：将Java堆分为新生代和老年代，按照不同的算法来处理不同区域的对象。新生代通常用复制算法回收，老年代通常采用标记-整理算法进行回收。

垃圾回收是JVM内存管理的重要概念。虽然各种算法在实现上有不同的优缺点，但是在实践中需要根据使用环境来灵活地选择不同的算法。具体介绍如下：

5.1如何判断队对象可以回收

在JVM中，垃圾回收器通过判定对象是否能被回收来决定是否对其进行回收。判断对象是否 “可回收” 通常需要执行下面两个步骤：

5.1.1 引用计数方法

引用计数算法是最简单的垃圾回收算法之一，它的思路很简单：给对象添加一个引用计数器，当对象新建或引用它时，计数器值加一，当对象的引用被移动或被删除时，计数器值减一。当计数器计数值为0时，就认为对象可以被垃圾回收器回收。

但是，引用计数算法很难解决对象之间的循环依赖的问题，循环依赖的对象会相互引用，导致计数器的值不为0，导致无法被回收。因此，Java中不使用引用计数算法进行垃圾回收。

5.1.2可达性分析算法

现在Java中的垃圾回收主要使用可达性分析算法（Reachability Analysis）。即从进行垃圾回收的对象开始，沿着对象之间的引用链，通过一系列的复杂规则判断对象是否仍然需要被保留。如果无法被递归引用，就可以被垃圾回收器回收。

在这个算法中，“根集” 是一个固定清单，包括对象的静态变量引用、活动线程栈中的引用和JNI引用，具体介绍如下：在 Java 中，GC Root 对象是指不能回收的对象，可以作为 GC Root 的对象包括以下几类：

1. JVM 栈（也称为线程栈）
   JVM 栈中保存线程运行时的状态，包括局部变量、方法参数、返回地址等信息。JVM 栈中的对象是最短命的对象，当线程结束，对象也就不存在了，它们可以作为 GC Root。

2. 方法区
   方法区是 JVM 运行时存储类信息、常量池等数据的区域，包括静态变量、类属性等。在方法区中的对象是被所有线程共享的，它们可以作为 GC Root。

3. 本地方法栈
   本地方法栈是为 Java 语言编写的本地方法而分配的内存区域，与 JVM 栈相似。本地方法栈中的对象也是最短命的对象，当本地方法结束，对象就不存在了，它们可以作为 GC Root。

4. JNI 引用类型
   JNI（Java Native Interface）是一种允许 Java 代码与本地代码进行交互的机制，JNI 中用的是本地引用（Local Reference）类型的对象。这些对象在本地方法中会被申请，它们可以作为 GC Root 对象。

GC Root 对象是指不能回收的对象，只要它们是被虚拟机所引用的，就不会被垃圾回收器回收。JAVA 中用作 GC Root 的对象主要包括 JVM 栈、方法区、本地方法栈和 JNI 引用类型。

如果一个对象不在根集中，也不被在根集中的对象直接或间接引用，那么这个对象就是不可达的，被判定为垃圾对象，并且会被垃圾回收器定期从内存中清理出去。

总的来说，可达性分析算法弥补了引用计数算法的缺陷，并且是现代JVM垃圾回收算法的主要方法。它对于Java程序员而言是透明的，因为Java自己控制管理着引用，而开发人员不用关注对象的回收。

5.1.3四种引用

在Java类库中，引用是一种对象，用于存储与对象关联的指针或引用。在JVM中，Java语言定义了4种引用类型：强引用、软引用、弱引用和虚引用。下面对它们逐一进行介绍：

1. 强引用（Strong Reference）：
   强引用是指在程序代码中普遍存在的引用赋值，若一个对象具有强引用，垃圾回收器绝不会回收它。即使在内存不足的情况下，Java虚拟机宁可抛出OOM（Out Of Memory）错误，也不回收这种对象。
   示例代码：

Object object = new Object(); // 该对象具有强引用应用场景:在正常情况下使用，例如像我们平时引用对象时所使用的变量。

2. 软引用（Soft Reference）：
   软引用是一种相对强引用弱化了一些的引用，它可以让对象豁免一些垃圾回收，只有内存不足时才会回收。但是仍会延迟一段时间之后才会被真正回收。

示例代码：

Object object = new Object();
SoftReference