1.什么是空闲列表？

空闲列表（Free List） 是一种内存管理技术，主要用于跟踪和管理堆内存中可用的空闲块。它广泛应用于各种内存分配算法中，特别是在 分段分配（Segmented Allocation） 和 链式分配（Linked Allocation） 策略中。下面详细介绍空闲列表的工作原理及其特点。

空闲列表的基本概念

空闲列表是一种数据结构，用于维护堆内存中所有未被使用的内存块的信息。每个空闲块通常包含以下信息：

• 起始地址：该空闲块在内存中的起始位置。
• 大小：该空闲块的字节数。
• 下一个空闲块指针：指向列表中的下一个空闲块。

通过维护这样一个列表，内存分配器可以快速找到合适的空闲块来满足对象的分配请求，并在释放对象时将相应的内存块重新加入到空闲列表中。

工作原理

• 初始化：
  • 当 JVM 启动时，整个堆内存被视为一个大的空闲块，并将其添加到空闲列表中。
• 对象分配：
  • 当需要创建新对象时，内存分配器会遍历空闲列表，查找足够大的空闲块。
  • 如果找到合适的空闲块，则从该块中分配所需的空间，并更新空闲列表。
  • 如果找不到合适的大块，则可能需要触发垃圾回收或调整堆大小。
• 空闲块分割：
  • 为了提高内存利用率，分配器可能会将较大的空闲块分割成两部分：一部分用于分配对象，另一部分保留在空闲列表中作为新的空闲块。
• 合并相邻空闲块：
  • 当释放对象时，相应的内存块会被标记为空闲，并尝试与相邻的空闲块合并，以减少碎片化。
• 更新空闲列表：
  • 分配和释放操作都会导致空闲列表的变化。分配操作会移除或缩小某个空闲块，而释放操作会添加新的空闲块或合并现有块。

示例图解

假设有一个简单的堆内存结构如下：

+-------------------+
|       Free        |  Size: 100 bytes
|                   |
|                   |
+-------------------+
|      Allocated    |  Size: 50 bytes
|                   |
+-------------------+
|       Free        |  Size: 75 bytes
|                   |
+-------------------+

对应的空闲列表可能如下：

+-------------------+
|  Start Address: 0x1000  |
|  Size: 100 bytes     |
|  Next: 0x10080         |
+-------------------+
|  Start Address: 0x100D0 |
|  Size: 75 bytes      |
|  Next: null            |
+-------------------+

分配对象 A (Size: 30 bytes)

• 查找空闲块：
  • 查找第一个空闲块（Start Address: 0x1000, Size: 100 bytes），其大小足够分配对象 A。
• 分配空间：
  • 从该空闲块中分配 30 字节的空间给对象 A。
  • 更新空闲块的起始地址和大小。
• 更新空闲列表：
  • 修改第一个空闲块的起始地址为 0x1001E，大小变为 70 bytes。

结果如下：

+-------------------+
|       Free        |  Size: 70 bytes
|                   |
|                   |
+-------------------+
|      Allocated    |  Size: 30 bytes
|      [A]          |
+-------------------+
|      Allocated    |  Size: 50 bytes
|                   |
+-------------------+
|       Free        |  Size: 75 bytes
|                   |
+-------------------+

对应的空闲列表如下：

+-------------------+
|  Start Address: 0x1001E |
|  Size: 70 bytes       |
|  Next: 0x10080          |
+-------------------+
|  Start Address: 0x10080 |
|  Size: 75 bytes       |
|  Next: null             |
+-------------------+

释放对象 A

• 标记为空闲：
  • 将对象 A 所占的空间标记为空闲。
• 合并相邻空闲块：
  • 检查相邻的空闲块，发现前一个空闲块（Start Address: 0x1001E, Size: 70 bytes）和当前释放的块可以合并。
  • 合并这两个空闲块，形成一个新的空闲块。
• 更新空闲列表：
  • 移除旧的空闲块，并更新合并后的空闲块信息。

结果如下：

+-------------------+
|       Free        |  Size: 100 bytes
|                   |
|                   |
+-------------------+
|      Allocated    |  Size: 50 bytes
|                   |
+-------------------+
|       Free        |  Size: 75 bytes
|                   |
+-------------------+

对应的空闲列表如下：

+-------------------+
|  Start Address: 0x1000  |
|  Size: 100 bytes     |
|  Next: 0x10080         |
+-------------------+
|  Start Address: 0x10080 |
|  Size: 75 bytes      |
|  Next: null            |
+-------------------+

特点和优势

• 高效性：
  • 空闲列表允许快速查找和分配空闲块，适合动态内存分配场景。
• 灵活性：
  • 可以灵活地处理不同大小的对象分配请求。
• 简单实现：
  • 相比于其他复杂的内存管理策略，空闲列表的实现相对简单。
• 降低碎片化：
  • 通过合并相邻的空闲块，可以有效减少内存碎片化。

注意事项

• 碎片化问题：
  • 即使使用空闲列表，长时间运行的应用程序也可能出现内存碎片化的问题。
  • 定期进行垃圾回收可以帮助减少碎片化。
• 搜索时间：
  • 在大型堆中，查找合适的空闲块可能会消耗较多的时间。
  • 可以采用不同的搜索策略（如最佳适应、首次适应等）来优化性能。
• 锁竞争：
  • 在多线程环境中，访问空闲列表可能导致锁竞争。
  • 可以使用细粒度锁或多线程友好的分配策略来缓解这个问题。

总结

空闲列表是一种有效的内存管理技术，广泛应用于各种内存分配算法中。通过维护一个记录所有空闲块的数据结构，它可以快速地分配和释放内存，从而提高内存利用率和系统性能。

2.什么是TLAB ？

TLAB（Thread Local Allocation Buffer） 是 Java 虚拟机（JVM）中的一种优化技术，主要用于提高多线程环境下对象分配的性能。通过将每个线程的对象分配空间独立化，TLAB 减少了线程间竞争和锁的开销，从而提升了整体吞吐量。下面详细介绍 TLAB 的工作原理及其优势。

TLAB 的基本概念

TLAB 是为每个线程预先分配的一小块内存区域，专门用于该线程创建的对象。当一个线程需要创建新对象时，它首先尝试从自己的 TLAB 中分配内存。只有在 TLAB 不足时，才会请求更多的内存或从共享的堆内存中分配。

工作原理

• 初始化：
  • 当 JVM 启动并创建线程时，会为每个线程分配一个 TLAB。
  • TLAB 的大小可以根据 JVM 参数进行配置，默认情况下由 JVM 自动调整。
• 对象分配：
  • 线程在创建新对象时，首先检查其 TLAB 是否有足够的空间。
  • 如果有足够空间，则直接在 TLAB 中分配对象，并移动 TLAB 的顶部指针。
  • 如果没有足够空间，则向全局堆请求新的 TLAB 或者直接从堆中分配对象。
• TLAB 回收：
  • 当 TLAB 被耗尽时，线程会请求一个新的 TLAB。
  • 旧的 TLAB 中的对象会被标记为存活，后续会被垃圾回收器处理。
• 动态调整：
  • JVM 可以根据实际使用情况动态调整 TLAB 的大小，以平衡分配效率和内存利用率。

示例图解

假设有一个简单的多线程环境，有两个线程 Thread A 和 Thread B，各自拥有一个 TLAB：

+-------------------+
|    Thread A       |
|  +-------------+  |
|  |     TLAB    |  |
|  | [Object 1]  |  |
|  | [Object 2]  |  |
|  +-------------+  |
+-------------------+

+-------------------+
|    Thread B       |
|  +-------------+  |
|  |     TLAB    |  |
|  | [Object 3]  |  |
|  |             |  |
|  +-------------+  |
+-------------------+

分配对象 C (Size: 10 bytes) 到 Thread A

• 检查 TLAB 空间：
  • Thread A 检查其 TLAB 是否有足够的空间来分配对象 C（10 bytes）。
  • 假设 TLAB 还有足够的空间。
• 分配对象 C：
  • 在 TLAB 中分配 10 字节的空间给对象 C。
  • 移动 TLAB 的顶部指针。

结果如下：

+-------------------+
|    Thread A       |
|  +-------------+  |
|  |     TLAB    |  |
|  | [Object 1]  |  |
|  | [Object 2]  |  |
|  | [Object C]  |  |
|  +-------------+  |
+-------------------+

+-------------------+
|    Thread B       |
|  +-------------+  |
|  |     TLAB    |  |
|  | [Object 3]  |  |
|  |             |  |
|  +-------------+  |
+-------------------+

分配对象 D (Size: 50 bytes) 到 Thread B

• 检查 TLAB 空间：
  • Thread B 检查其 TLAB 是否有足够的空间来分配对象 D（50 bytes）。
  • 假设 TLAB 不足以容纳对象 D。
• 请求新的 TLAB 或直接分配：
  • Thread B 请求一个新的 TLAB 或者直接从全局堆中分配对象 D。

结果如下：

+-------------------+
|    Thread A       |
|  +-------------+  |
|  |     TLAB    |  |
|  | [Object 1]  |  |
|  | [Object 2]  |  |
|  | [Object C]  |  |
|  +-------------+  |
+-------------------+

+-------------------+
|    Thread B       |
|  +-------------+  |
|  |     TLAB    |  |
|  | [Object D]  |  |
|  |             |  |
|  +-------------+  |
+-------------------+

特点和优势

• 减少锁竞争：
  • 每个线程都有自己独立的 TLAB，减少了对全局堆锁的竞争。
  • 大多数对象分配都在本地完成，降低了锁的开销。
• 提高分配速度：
  • 使用指针碰撞（Pointer Bumping）技术，在 TLAB 中分配对象非常高效。
  • 避免了频繁的锁获取和释放操作，提高了对象分配的速度。
• 降低碎片化：
  • TLAB 中的对象通常是连续分配的，减少了内存碎片化的问题。
  • 有利于提高缓存命中率，提升整体性能。
• 动态调整：
  • JVM 可以根据实际应用的需求动态调整 TLAB 的大小。
  • 适应不同的应用场景，优化内存分配策略。

配置参数

JVM 提供了一些参数来控制 TLAB 的行为：

• -XX:+UseTLAB：启用 TLAB（默认启用）。
• -XX:-UseTLAB：禁用 TLAB。
• -XX:TLABSize=：设置 TLAB 的初始大小。
• -XX:TLABRefillWasteFraction=：设置 TLAB 再填充浪费分数。
• -XX:MinTLABSize=：设置 TLAB 的最小大小。
• -XX:MaxTLABSize=：设置 TLAB 的最大大小。

注意事项

• 线程数量：
  • 如果线程数量过多，可能会导致大量的 TLAB 分配，增加管理开销。
  • 需要根据实际情况调整线程池大小和 TLAB 参数。
• 对象大小：
  • 对于非常大的对象，通常不会分配到 TLAB，而是直接从全局堆中分配。
  • 需要注意大对象的分配策略，避免不必要的性能开销。
• 垃圾回收：
  • TLAB 中的对象在 TLAB 被耗尽后会被标记为存活，参与垃圾回收过程。
  • 适当的 TLAB 大小可以帮助减少垃圾回收的压力。

总结

TLAB 是一种重要的内存分配优化技术，通过为每个线程分配独立的内存区域，显著提高了多线程环境下对象分配的性能。通过减少锁竞争、提高分配速度和降低碎片化，TLAB 成为现代 JVM 中不可或缺的一部分。

3.对象头具体都包含哪些内容？

在 Java 虚拟机（JVM）中，对象头（Object Header） 是每个对象都必须包含的一个部分，用于存储与对象相关的重要元数据信息。对象头的结构和内容因 JVM 的具体实现而异，但通常包含以下几个关键部分：

对象头的基本结构

Java 对象头主要由两部分组成：

• Mark Word：用于存储对象的运行时数据。
• Klass Pointer：指向对象所属类的元数据（在某些情况下可以省略）。

1. Mark Word

Mark Word 是对象头中最重要的一部分，用于存储对象的状态信息、哈希码、GC 状态、锁状态等。具体的结构取决于 JVM 的实现，以下是一些常见的字段：

• Hashcode：对象的哈希码值，用于 hashCode() 方法。
• Age：对象的年龄，用于判断对象是否需要晋升到老年代。
• Biased Locking：偏向锁的信息，用于轻量级锁优化。
• Lock Status：对象的锁定状态，包括无锁、偏向锁、轻量级锁、重量级锁等。
• GC Metadata：垃圾回收相关的标志位，如可达性标记等。
• Thread ID：持有偏向锁的线程 ID。
• Epoch：偏向锁的时间戳或版本号。

2. Klass Pointer

Klass Pointer 指向对象所属类的元数据（klass 结构），包含了类的详细信息，如父类、方法表、字段信息等。在某些情况下，特别是压缩指针启用的情况下，Klass Pointer 可能被省略或合并到 Mark Word 中。

具体示例

以下是一个典型的 64 位 JVM 中对象头的结构示意图：

+--------------------------------------------------+
|                    Mark Word                     |
|--------------------------------------------------|
| Hashcode | Age | Biased Locking | Lock Status    |
+--------------------------------------------------+
|                 Klass Pointer                    |
+--------------------------------------------------+

Mark Word 的详细结构

在不同的 JVM 实现中，Mark Word 的具体结构可能会有所不同。以下是 HotSpot JVM 中的一种常见结构：

+--------------------------------------------------+
| hashcode:25 | age:4 | biased_lock:1 | lock:2     |
+--------------------------------------------------+
| thread_id:54 | epoch:2                          |
+--------------------------------------------------+

• hashcode:25：对象的哈希码值。
• age:4：对象的年龄，用于分代垃圾回收。
• biased_lock:1：表示是否启用了偏向锁。
• lock:2：表示对象的锁定状态（0b00 表示无锁，0b01 表示偏向锁，0b10 表示轻量级锁，0b11 表示重量级锁）。
• thread_id:54：持有偏向锁的线程 ID。
• epoch:2：偏向锁的时间戳或版本号。

压缩指针

为了节省内存，现代 JVM 通常会启用压缩指针（Compressed Pointers）。压缩指针技术通过使用较小的指针大小来减少内存占用。例如，在 64 位 JVM 上，Klass Pointer 和普通对象引用可以被压缩为 32 位。

启用压缩指针

可以通过以下 JVM 参数启用压缩指针：

• -XX:+UseCompressedOops：启用压缩对象指针。
• -XX:+UseCompressedClassPointers：启用压缩类指针。

示例代码

虽然对象头的内容不能直接通过 Java 代码访问，但我们可以通过一些工具和技术来观察和分析对象头的信息。例如，使用 jol-core 库可以查看对象头的布局和大小。

[<title="使用 jol-core 查看对象头信息">]
import org.openjdk.jol.info.ClassLayout;

public class ObjectHeaderExample {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        System.out.println(ClassLayout.parseInstance(obj).toPrintable());
    }
}

class MyClass {
    private int value;
}

运行上述代码，输出可能如下所示：

com.example.ObjectHeaderExample$MyClass object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0    12        (object header)                           N/A
     12     4   int MyClass.value                             N/A
     16     4        (loss due to the next object alignment)
Instance size: 20 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

在这个输出中，(object header) 部分代表了对象头的大小和内容。

总结

Java 对象头是每个对象不可或缺的一部分，包含了对象的运行时元数据信息。主要包括 Mark Word 和 Klass Pointer 两个部分。Mark Word 存储了对象的状态信息、哈希码、GC 状态、锁状态等，而 Klass Pointer 指向对象所属类的元数据。通过理解对象头的结构和内容，可以更好地掌握 JVM 内存管理和对象生命周期的相关知识。

4.你知道哪些JVM调优参数？

JVM 调优参数是用于调整 Java 虚拟机的行为和性能的关键设置。通过合理配置这些参数，可以显著提升应用程序的性能、稳定性和资源利用率。以下是一些常用的 JVM 调优参数及其作用：

堆内存调优参数

• 1. 初始堆大小 (-Xms)
  • 作用：设置 JVM 启动时分配的初始堆内存大小。

示例：

-Xms512m

• 2. 最大堆大小 (-Xmx)
  • 作用：设置 JVM 允许的最大堆内存大小。

示例：

-Xmx2g

• 3. 新生代大小 (-Xmn)
  • 作用：设置新生代（Young Generation）的大小。

示例：

-Xmn768m

• 4. 年轻代 Eden 区大小 (-XX:NewRatio)
  • 作用：设置年轻代中 Eden 区与 Survivor 区的比例。默认值为 2，表示 Eden 区占 2/3，每个 Survivor 区占 1/6。

示例：

-XX:NewRatio=3

• 5. Survivor 区比例 (-XX:SurvivorRatio)
  • 作用：设置 Eden 区与 Survivor 区的比例。默认值为 8，表示 Eden 区占 8/10，每个 Survivor 区占 1/10。

示例：

-XX:SurvivorRatio=6

• 6. 压缩指针 (-XX:+UseCompressedOops)
  • 作用：启用压缩对象指针，减少 64 位 JVM 中的对象引用大小。

示例：

-XX:+UseCompressedOops

• 7. 压缩类指针 (-XX:+UseCompressedClassPointers)
  • 作用：启用压缩类指针，减少 64 位 JVM 中的类引用大小。

示例：

-XX:+UseCompressedClassPointers

垃圾回收调优参数

• 1. G1 垃圾收集器 (-XX:+UseG1GC)
  • 作用：启用 G1 垃圾收集器。

示例：

-XX:+UseG1GC

• 2. CMS 垃圾收集器 (-XX:+UseConcMarkSweepGC)
  • 作用：启用 CMS（Concurrent Mark Sweep）垃圾收集器。

示例：

-XX:+UseConcMarkSweepGC

• 3. Parallel GC (-XX:+UseParallelGC)
  • 作用：启用 Parallel GC（并行垃圾收集器）。

示例：

-XX:+UseParallelGC

• 4. Parallel Old GC (-XX:+UseParallelOldGC)
  • 作用：启用 Parallel Old GC（并行老年代垃圾收集器）。

示例：

-XX:+UseParallelOldGC

• 5. Young GC 线程数 (-XX:ParallelGCThreads)
  • 作用：设置 Young GC 使用的线程数。

示例：

-XX:ParallelGCThreads=4

• 6. Old GC 线程数 (-XX:ConcGCThreads)
  • 作用：设置 Concurrent GC 使用的线程数。

示例：

-XX:ConcGCThreads=2

• 7. G1 Region 大小 (-XX:G1HeapRegionSize)
  • 作用：设置 G1 垃圾收集器中每个 region 的大小。

示例：

-XX:G1HeapRegionSize=16m

• 8. G1 并发标记线程数 (-XX:ConcGCThreads)
  • 作用：设置 G1 并发标记阶段使用的线程数。

示例：

-XX:ConcGCThreads=4

• 9. G1 Initiating Heap Occupancy Percent (-XX:InitiatingHeapOccupancyPercent)
  • 作用：设置触发并发标记周期的堆占用百分比。

示例：

-XX:InitiatingHeapOccupancyPercent=45

内存映射文件调优参数

• 1. Metaspace 大小 (-XX:MetaspaceSize)
  • 作用：设置 Metaspace 的初始大小。

示例：

-XX:MetaspaceSize=256m

• 2. 最大 Metaspace 大小 (-XX:MaxMetaspaceSize)
  • 作用：设置 Metaspace 的最大大小。

示例：

-XX:MaxMetaspaceSize=512m

• 3. PermGen 大小 (-XX:PermSize 和 -XX:MaxPermSize)
  • 作用：设置永久代（PermGen）的初始和最大大小（已弃用，推荐使用 Metaspace）。

示例：

-XX:PermSize=128m
-XX:MaxPermSize=256m

其他常用参数

• 1. 禁用偏向锁 (-XX:-UseBiasedLocking)
  • 作用：禁用偏向锁。

示例：

-XX:-UseBiasedLocking

• 2. 启用逃逸分析 (-XX:+DoEscapeAnalysis)
  • 作用：启用逃逸分析优化。

示例：

-XX:+DoEscapeAnalysis

• 3. 禁用逃逸分析 (-XX:-DoEscapeAnalysis)
  • 作用：禁用逃逸分析优化。

示例：

-XX:-DoEscapeAnalysis

• 4. 启用 JIT 编译器 (-client 或 -server)
  • 作用：选择客户端或服务器模式的 JIT 编译器。

示例：

-client
-server

• 5. 日志输出 (-Xloggc:)
  • 作用：将垃圾回收日志输出到指定文件。

示例：

-Xloggc:/path/to/gc.log

• 6. 输出详细 GC 日志 (-verbose:gc)
  • 作用：输出详细的垃圾回收日志信息。

示例：

-verbose:gc

• 7. 设置 GC 日志格式 (-XX:+PrintGCDetails)
  • 作用：打印详细的 GC 日志信息。

示例：

-XX:+PrintGCDetails

• 8. 设置 GC 日志时间戳 (-XX:+PrintGCTimeStamps)
  • 作用：在 GC 日志中添加时间戳。

示例：

-XX:+PrintGCTimeStamps

• 9. 设置 GC 日志日期戳 (-XX:+PrintGCDateStamps)
  • 作用：在 GC 日志中添加日期时间戳。

示例：

-XX:+PrintGCDateStamps

• 10. 设置 GC 日志轮转 (-XX:+UseGCLogFileRotation)
  • 作用：启用 GC 日志文件轮转。

示例：

-XX:+UseGCLogFileRotation

• 11. 设置 GC 日志文件数量 (-XX:NumberOfGCLogFiles)
  • 作用：设置 GC 日志文件的数量。

示例：

-XX:NumberOfGCLogFiles=5

• 12. 设置 GC 日志文件大小 (-XX:GCLogFileSize)
  • 作用：设置每个 GC 日志文件的大小。

示例：

-XX:GCLogFileSize=10M

• 13. 设置线程堆栈大小 (-Xss)
  • 作用：设置每个线程的堆栈大小。

示例：

-Xss1m

• 14. 设置最大直接内存大小 (-XX:MaxDirectMemorySize)
  • 作用：设置 JVM 可以使用的最大直接内存大小。

示例：

-XX:MaxDirectMemorySize=256m

• 15. 设置最大内联方法大小 (-XX:MaxInlineSize)
  • 作用：设置方法内联的最大字节码大小。

示例：

-XX:MaxInlineSize=35

• 16. 设置最大内联层次深度 (-XX:MaxRecursiveInlineLevel)
  • 作用：设置递归内联的最大层次深度。

示例：

-XX:MaxRecursiveInlineLevel=1

• 17. 设置最大内联方法大小 (-XX:LargeMethodThreshold)
  • 作用：设置认为是“大”方法的阈值字节数。

示例：

-XX:LargeMethodThreshold=32768

• 18. 启用 TLAB (-XX:+UseTLAB)
  • 作用：启用 Thread Local Allocation Buffers (TLAB)。

示例：

-XX:+UseTLAB

• 19. 设置 TLAB 大小 (-XX:TLABSize)
  • 作用：设置 TLAB 的初始大小。

示例：

-XX:TLABSize=1m

• 20. 设置 TLAB 最大浪费比例 (-XX:TLABRefillWasteFraction)
  • 作用：设置 TLAB 再填充时允许的最大浪费比例。

示例：

-XX:TLABRefillWasteFraction=64

示例

以下是一个综合示例，展示了如何配置一些常用的 JVM 调优参数：

java -Xms512m -Xmx2g -Xmn768m -XX:NewRatio=3 -XX:SurvivorRatio=6 \
     -XX:+UseG1GC -XX:G1HeapRegionSize=16m -XX:ConcGCThreads=4 \
     -XX:InitiatingHeapOccupancyPercent=45 -XX:+UseCompressedOops \
     -XX:+UseCompressedClassPointers -XX:MetaspaceSize=256m \
     -XX:MaxMetaspaceSize=512m -XX:+DoEscapeAnalysis -XX:+UseTLAB \
     -Xss1m -Xloggc:/path/to/gc.log -verbose:gc -XX:+PrintGCDetails \
     -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -XX:+UseGCLogFileRotation \
     -XX:NumberOfGCLogFiles=5 -XX:GCLogFileSize=10M MyApplication

5.说一下 JVM 有哪些垃圾回收器？

Java 虚拟机（JVM）提供了多种垃圾回收器（Garbage Collectors），每种垃圾回收器都有其独特的特性和适用场景。以下是 JVM 中常见的几种垃圾回收器及其详细说明：

1. Serial Garbage Collector

适用场景：

• 单线程环境。
• 简单的应用程序或小型系统。

特点：

• 单线程：使用单个线程进行垃圾回收，会导致应用程序在垃圾回收期间暂停（Stop-The-World, STW）。
• 简单高效：适用于内存较小且不需要高并发的应用程序。
• 低开销：由于只有一个线程参与垃圾回收，开销较低。

启用参数：

-XX:+UseSerialGC

示例

java -XX:+UseSerialGC MyApplication

2. Parallel Garbage Collector (Throughput Collector)

适用场景：

• 多核处理器。
• 需要高吞吐量的应用程序。
• 对延迟要求不高。

特点：

• 多线程：使用多个线程并行执行垃圾回收，减少 STW 时间。
• 高吞吐量：适合需要最大化 CPU 使用率的批处理作业。
• 可配置性：可以通过参数调整线程数和堆大小。

启用参数：

-XX:+UseParallelGC

示例

java -XX:+UseParallelGC -XX:ParallelGCThreads=4 -Xmx2g MyApplication

3. Concurrent Mark-Sweep (CMS) Garbage Collector

适用场景：

• 需要低延迟的应用程序。
• 实时系统或交互式应用。
• 内存较大且对停顿时间敏感。

特点：

• 并发收集：大部分工作在应用程序运行时并发执行，减少 STW 时间。
• 低停顿：适合需要快速响应的应用程序。
• 碎片化问题：长时间运行可能导致严重的内存碎片化。
• 已弃用：从 JDK 9 开始，CMS 收集器已被标记为过时，并将在未来的版本中移除。

启用参数：

-XX:+UseConcMarkSweepGC

示例

java -XX:+UseConcMarkSweepGC -Xmx2g MyApplication

4. G1 Garbage Collector

适用场景:

• 大型堆内存。
• 需要平衡吞吐量和延迟的应用程序。
• 对停顿时间有一定要求。

特点:

• 分区收集：将堆内存划分为多个区域（regions），按需进行垃圾回收。
• 并发与并行：结合了 CMS 和 Parallel GC 的优点，支持并发标记和并行清除。
• 预测性：能够预测未来的停顿时间，动态调整回收行为。
• 低停顿：适合需要低延迟的应用程序。
• 自动调优：内置了许多自适应机制，减少了手动调优的需求。

启用参数:

-XX:+UseG1GC

示例

java -XX:+UseG1GC -Xmx4g -XX:MaxGCPauseMillis=200 MyApplication

5. Z Garbage Collector (ZGC)

适用场景:

• 极大堆内存（数百 GB 到 TB）。
• 对停顿时间有严格要求的实时系统。
• 高吞吐量需求。

特点:

• 低停顿：承诺不超过 10 毫秒的停顿时间，即使在大规模堆内存下也是如此。
• 并发收集：几乎所有的垃圾回收工作都是并发执行的。
• 压缩堆：消除内存碎片，提高内存利用率。
• 低延迟：非常适合需要极低延迟的应用程序。
• 实验性：从 JDK 11 开始引入，仍在不断发展和完善。

启用参数:

-XX:+UseZGC

示例

java -XX:+UseZGC -Xmx1t MyApplication

6. Shenandoah Garbage Collector

适用场景:

• 大型堆内存。
• 对停顿时间有严格要求的实时系统。
• 高吞吐量需求。

特点:

• 低停顿：承诺不超过 10 毫秒的停顿时间。
• 并发收集：大多数垃圾回收工作是并发执行的。
• 压缩堆：通过压缩技术减少内存碎片。
• 无分代：采用不分代的设计，简化了垃圾回收过程。
• 成熟稳定：经过多年的开发和优化，已在生产环境中广泛应用。

启用参数:

-XX:+UseShenandoahGC

示例

java -XX:+UseShenandoahGC -Xmx4g MyApplication

7. Epsilon Garbage Collector (NoOp GC)

适用场景:

• 测试和基准测试。
• 不需要垃圾回收的应用程序（如嵌入式系统）。

特点:

• 无操作：不进行任何垃圾回收，适用于不需要垃圾回收的特殊场景。
• 内存泄漏：如果不小心使用，可能会导致内存泄漏。
• 简单高效：适用于简单的测试环境或特定应用场景。

启用参数:

-XX:+UseEpsilonGC

示例

java -XX:+UseEpsilonGC -Xmx512m MyApplication

总结

选择合适的垃圾回收器取决于具体的应用需求和硬件资源。以下是一些常见的选择建议：

• 单线程或小型应用：使用 Serial GC。
• 多核处理器、高吞吐量需求：使用 Parallel GC。
• 低延迟、实时系统：考虑 G1 GC 或 Shenandoah GC。
• 极大堆内存、超低延迟：使用 ZGC 或 Shenandoah GC。
• 测试和基准测试：使用 Epsilon GC。