JVM的学习

内存模型

JVM内存模型主要是指Java虚拟机在运行时所使用的内存结构。它主要包括堆、栈、方法区和程序计数器等部分。
堆是JVM中最大的一块内存区域，用于存储对象实例。一般通过new关键字创建的对象都存放在堆中，堆的大小可以通过启动参数进行调整。堆被所有线程共享，但是它的访问是线程不安全的，需要通过锁机制来保证线程安全。
栈用于存储方法调用和局部变量。每个线程在运行时都会有一个独立的栈，栈中的每个方法调用都会创建一个栈帧，栈帧包含了方法的参数、局部变量和返回值等信息。栈的大小是固定的，并且栈中的数据是线程私有的，不会被其他线程访问。
方法区用于存储类的信息和静态变量。它是所有线程共享的内存区域，存储了类的结构信息、常量池、静态变量和方法字节码等。方法区的大小也可以通过启动参数进行调整。
程序计数器是每个线程私有的，用于记录当前线程执行的字节码指令的地址。每个线程都有一个独立的程序计数器，用于控制线程的执行流程。
JVM内存模型的设计可以提供内存管理和线程安全的机制，同时也保证了Java程序的跨平台性。不同的内存区域有不同的作用和访问规则，合理地管理和利用这些内存区域可以提高Java程序的性能和稳定性。

常量池

常量池是Java编程语言中的一个重要概念，它是一种用于存储常量值、符号引用和字面量的数据结构，主要用于提高代码的效率和减少内存消耗。对于类级别的常量池，它存储在类文件class中，对于运行时常量池，它存储在内存中，用于支持类加载后的运行时解析。常量池中的数据项是不可改变的，一旦创建就不能修改。常量池中的数据项是唯一的，相同的常量值或符号引用在常量池中只会出现一次。
常量池允许多个类或方法共享相同的常量值，减少了内存占用。在运行时，Java虚拟机会根据符号引用在常量池中查找对应的实际信息，如类、方法、字段等。
字符串常量池也是常量池的一个重要部分，用于存储字符串字面量。字符串常量池中的字符串是唯一的，相同内容的字符串在池中只有一个副本。字符串常量池的优化提高了字符串的比较效率，例如使用equals()方法比较字符串时，可以直接比较引用。
在Java编程中，程序员通常不需要直接操作常量池，因为Java编译器和虚拟机会自动管理它。

常量池存储区域

常量池一般存储在JVM的方法区(或者元空间)。但是字符串常量池比较特殊，不同JDK版本存储位置有点不同，拿Java 8来说，字符串常量池是存储在堆内存中的，用于存储字符串字面量。这是一个特殊的堆内存区域，用于提高字符串操作的效率和节省内存。字符串常量池中的字符串是唯一的，相同的字符串字面量在常量池中只有一个副本。

内存溢出与内存泄漏

内存溢出和内存泄漏都是与内存管理相关的问题，但它们有不同的表现和发生原因。
内存溢出是指程序尝试分配更多内存空间，而可用内存已经用尽，因此无法满足分配的请求。它通常发生在程序执行期间，例如创建新对象或递归调用时，需要分配内存，但没有足够的内存可供分配。内存溢出通常导致程序崩溃或抛出OutOfMemoryError异常。
内存泄漏是指程序分配了一些内存，但在不再需要这些内存时没有释放它们。它通常不会导致程序立即崩溃，但随着时间的推移，占用的内存不断增加，最终可能导致程序变得非常缓慢或耗尽系统资源。内存泄漏通常是由于程序中的错误代码、不正确的引用管理或资源未正确关闭等原因引起的。
预防内存溢出通常需要分配足够的内存，而预防内存泄漏需要确保及时释放不再需要的内存。调试和解决内存泄漏问题通常更具挑战性，因为它们不会立即导致程序失败，而且可能需要工具和技术来识别和解决。

对象分配规则

在Java中，对象分配规则是关于如何为新对象分配内存的一套规则，以确保内存的有效使用和对象的正确初始化。以下是关于对象分配的主要规则：
1. 内存分配：新对象通常在堆内存中分配内存空间。
2. 对象头：在为对象分配内存空间后，Java虚拟机会为对象分配一个对象头。对象头包含了一些关于对象的元信息，如对象的哈希码、锁状态、垃圾回收信息等。
3. 零值初始化：在对象内存分配后，所有的成员变量会被初始化为零值。具体的零值取决于变量的数据类型。例如，整数类型会初始化为0，布尔类型会初始化为false，对象引用会初始化为null。
4. 构造函数调用：一旦对象内存分配和零值初始化完成，Java虚拟机会调用对象的构造函数。
5. 对象引用：最后，new 关键字会返回对象的引用，将这个引用分配给一个变量，以便后续可以通过该变量访问对象的属性和方法。
6. 垃圾回收管理：Java虚拟机会自动管理对象的内存。如果对象不再被引用，它会被标记为垃圾，并在适当的时机由垃圾回收器回收，释放占用的内存。
这些规则确保了对象在创建时的正确初始化和内存管理。对于程序员来说，最重要的是编写好构造函数以确保对象在创建后具有合适的初始状态，并且不忘记在不再需要对象时将引用置为null，以便垃圾回收器能够回收不再使用的对象。

对象大小计算

在Java中，对象的大小通常是由对象的实例变量、对象头和内部填充组成的。对象的大小计算方法可以简化为以下几个步骤：
1. 计算对象头大小：对象头包含了一些关于对象的元信息，如对象的哈希码、锁状态、垃圾回收信息等。对象头的大小在不同的JVM实现和配置下会有所不同。通常，对象头的大小在64位JVM是8个字节，在32位JVM是4个字节。
2. 计算实例变量大小：对象的实例变量是对象的数据部分，它们占用的内存空间由它们的数据类型和数量决定。例如，一个整数类型的实例变量在64位JVM是8个字节，在32位JVM是4个字节。
3. 计算内部填充大小：为了对齐数据，Java虚拟机通常在实例变量之间插入一些内部填充。填充的大小取决于虚拟机和操作系统的要求，通常是8字节的倍数。这样可以提高内存的访问效率。
综上，对象总大小等于对象头大小加上实例变量大小和内部填充的大小。

对象分配在堆中

不一定，对象还可以分配在栈上，对象栈上分配通常是指将对象引用分配到方法调用栈上，而不是在堆内存中分配对象的实例数据。这种分配方式主要涉及基于逃逸分析的优化技术。
逃逸分析是Java虚拟机的一种优化技术，用于分析对象的生命周期和作用域。如果分析表明某个对象的引用不会逃逸到方法调用栈之外，即不会被其他线程引用或返回给其他方法，那么Java虚拟机可能会将这个对象分配到栈上，而不是分配到堆内存中。
这样做的好处是可以显著提高对象的访问速度，因为栈上的对象引用可以更快地访问，而且不需要垃圾回收。但也需要注意以下几点：
1. 对象的生命周期有限：对象栈上分配的对象的生命周期通常限制在方法调用期间。一旦方法返回，栈上的对象引用将失效，对象的数据也将被销毁。
2. 不适用于大对象：栈内存通常有限，不适合分配大型对象。对于较大的对象，仍然会分配在堆内存中。
3. 逃逸分析优化：逃逸分析是一个复杂的优化过程，Java虚拟机会根据分析结果来决定是否执行栈上分配。不是所有的对象都会被栈上分配，只有那些符合条件的对象才会被优化。
4. 多线程安全性：栈上分配的对象通常只能在创建它的线程中使用，不适合在多线程环境下共享。

对象回收

在Java中，对象是否可以被回收通常由垃圾回收器决定。垃圾回收器使用一种称为"可达性分析"的算法来确定对象是否可被回收。可达性分析是指如果一个对象无法从任何GC Roots直接或间接访问到，它就被认为是不可达的，可以被垃圾回收。
GC Roots是一组特殊的引用，它们被认为是程序中可访问对象的起始点，即从这些引用开始，可以追踪到所有仍然被程序引用的对象。
GC Roots通常包括以下几种类型的引用：
1. 局部变量引用：在方法中定义的局部变量，包括方法的参数和局部变量，通常被视为GC Roots。这些变量的引用指向了对象的实例。
2. 活动线程引用：正在运行的线程的引用通常被视为GC Roots。线程本地存储中的对象也是如此。
3. 静态变量引用：静态变量是类的一部分，它们的引用也被视为GC Roots。静态变量存在于类加载器的内存中。
4. JNI 引用：通过Java Native Interface（JNI）创建的本地代码引用也可以被视为GC Roots。这些引用连接了Java堆内存和本地代码的内存。
5. 虚拟机引导类加载器：虚拟机内部使用的类加载器引用也是GC Roots。它们通常是一些核心类或库。

常用的JVM启动参数

JVM（Java虚拟机）的启动参数用于配置和调整Java应用程序的运行时行为。以下是一些常用的JVM启动参数：
1. -Xmx：指定Java堆内存的最大限制。例如，-Xmx512m 表示最大堆内存为512兆字节。
2. -Xms：指定Java堆内存的初始大小。例如，-Xms256m 表示初始堆内存为256兆字节。
3. -Xss：指定每个线程的堆栈大小。例如，-Xss256k 表示每个线程的堆栈大小为256千字节。
4. -XX:MaxPermSize（对于Java 7及之前的版本）或 -XX:MaxMetaspaceSize（对于Java 8及以后的版本）：指定永久代（Java 7及之前）或元空间（Java 8及以后）的最大大小。
5. -XX:PermSize（对于Java 7及之前的版本）或 -XX:MetaspaceSize（对于Java 8及以后的版本）：指定永久代（Java 7及之前）或元空间（Java 8及以后）的初始大小。
6. -Xmn：指定年轻代的大小。例如，-Xmn256m 表示年轻代大小为256兆字节。
7. -XX:SurvivorRatio：指定年轻代中Eden区与Survivor区的大小比例。例如，-XX:SurvivorRatio=8 表示Eden区与每个Survivor区的大小比例为8:1。
8. -XX:NewRatio：指定年轻代与老年代的大小比例。例如，-XX:NewRatio=2 表示年轻代和老年代的比例为1:2。
9. -XX:MaxGCPauseMillis：设置垃圾回收的最大暂停时间目标。例如，-XX:MaxGCPauseMillis=100 表示垃圾回收的最大暂停时间目标为100毫秒。
10. -XX:ParallelGCThreads：指定并行垃圾回收线程的数量。例如，-XX:ParallelGCThreads=4 表示使用4个线程进行并行垃圾回收。
11. -XX:+UseConcMarkSweepGC：启用并发标记清除垃圾回收器。
12. -XX:+UseG1GC：启用G1（Garbage First）垃圾回收器。
13. -Dproperty=value：设置Java系统属性，可以在应用程序中使用 System.getProperty("property") 来获取这些属性的值。
这些是一些常见的JVM启动参数，可以根据应用程序的需求和性能调优的目标进行调整。JVM启动参数的使用可以显著影响应用程序的性能和行为，因此在设置这些参数时需要谨慎。同时，JVM支持的启动参数因不同的JVM版本和供应商而有所不同，建议查阅相关文档以获取更详细的信息。

设置堆内存XMX

设置Java堆内存大小（-Xmx参数）是一个重要的性能调优决策，需要考虑多个因素，以确保应用程序在合适的内存限制下运行顺畅，避免内存不足或内存浪费的问题。以下是考虑设置-Xmx参数时需要考虑的因素：
1. **应用程序的内存需求**：首先要了解应用程序的内存需求。这包括应用程序的数据量、并发用户数、对象创建频率等。不同的应用程序可能需要不同大小的堆内存。
2. **应用程序的性能需求**：性能目标对内存大小有很大的影响。如果需要更高的吞吐量和更低的延迟，可能需要分配更多的内存。但要小心不要分配过多，以避免浪费内存。
3. **可用物理内存**：要考虑服务器或计算机上的可用物理内存量。将-Xmx参数设置为超过物理内存容量的值可能会导致操作系统频繁地进行内存交换，降低性能。
4. **垃圾回收的开销**：堆内存越大，垃圾回收的开销通常也会增加。大堆内存可能需要更长的垃圾回收暂停时间。因此，要权衡内存大小和垃圾回收开销。
5. **堆内存分代结构**：Java堆内存通常分为年轻代、老年代和永久代（或元空间，取决于JVM版本）。不同代的分配比例和大小会影响-Xmx的设置。根据应用程序的特性，可以考虑调整不同代的大小。
6. **监控和调整**：监控应用程序的内存使用情况，使用工具如JVisualVM、JConsole等来观察堆内存的使用情况。根据监控数据进行动态调整-Xmx参数。
7. **应用程序设计**：合理的应用程序设计也可以影响堆内存需求。避免内存泄漏和不必要的对象创建可以降低内存需求。
8. **并发性需求**：多线程应用程序通常需要更多的堆内存，因为每个线程都需要一定的内存空间来存储栈帧和局部变量。
9. **JVM版本和垃圾回收器**：不同的JVM版本和垃圾回收器可能对内存需求有不同的影响。某些垃圾回收器可能更适合大堆内存，而某些适用于小堆内存。
综合考虑这些因素，需要进行实际的性能测试和监控来确定合适的-Xmx参数值。通常建议开始时设置一个合理的初始值，然后通过性能测试和监控来逐渐调整，以满足应用程序的需求并避免不必要的内存浪费。不同的应用程序可能需要不同的内存配置，因此没有一种大小适合所有情况的通用规则。

CPU百分百排查

排查CPU百分百问题通常需要一步一步地识别并解决潜在的原因。以下是一些常见的排查步骤：
1. 查看系统负载：首先，使用系统监控工具比如top查看系统的负载情况。
2. 确定是哪个进程导致CPU高占用：查找哪个进程或应用程序的CPU占用率很高。通常，系统监控工具会列出占用CPU较多的进程。注意，有时一个进程的子进程也可能引起CPU高占用。
3. 查看日志文件：检查应用程序的日志文件，查找是否有异常或错误消息。
4. 检查代码：如果是自己开发的应用程序，检查代码以查找是否存在性能问题，例如死循环、低效的算法、内存泄漏等。使用性能分析工具来帮助确定瓶颈。
5. 查看数据库查询：如果应用程序与数据库交互，查询可能导致CPU负载高。通过检查数据库的慢查询日志和优化查询来解决问题。
6. 监控线程：如果是多线程应用程序，检查是否有某些线程占用了大量CPU资源。使用线程分析工具来识别问题线程。
7. 查看网络连接：有时，网络请求和连接问题也可能导致CPU高占用。查看是否有异常的网络连接或请求。
8. 使用性能分析工具：使用专业的性能分析工具来检测瓶颈。例如，Java应用程序可以使用Arthas、VisualVM等工具进行分析。
9. 应用程序优化：根据排查的结果，对应用程序进行优化，修复性能问题。

强引用、软引用、弱引用、虚引用

在Java中，强引用、软引用、弱引用和虚引用是不同类型的引用，用于管理对象的生命周期。它们之间的主要区别在于对象被垃圾回收的条件和时机。
强引用是最常见的引用类型，通常通过赋值操作创建。当一个对象具有强引用时，垃圾回收器不会回收它，即使内存不足也不会回收。
软引用通过SoftReference类来表示。软引用用于描述那些内存不是必需的但仍然有用的对象。当内存不足时，垃圾回收器会尝试回收软引用对象，但只有在内存真正不足的情况下才会回收。软引用通常用于实现高速缓存，以便在内存不足时释放缓存中的对象。
弱引用通过WeakReference类来表示。弱引用用于描述那些不会阻止对象被垃圾回收的对象。如果一个对象只有弱引用指向它，那么垃圾回收器会在下一次运行时回收该对象。弱引用通常用于构建可以在对象不再被强引用时自动释放的数据结构，如哈希表的键。
虚引用通过PhantomReference类来表示。虚引用用于监控对象被垃圾回收的情况，但本身并不阻止对象被回收。虚引用通常与ReferenceQueue一起使用，当对象被回收时，虚引用会被放入引用队列中，以便应用程序可以了解到对象何时被回收。

类加载器机制与双亲委派

Java类加载器机制是JVM用于加载类文件到内存中的核心机制。它采用了一种层级结构和双亲委派模型，确保了类的唯一性和安全性。
类加载机制是类加载器负责将类文件加载到JVM的内存中，使得类可以被实例化和调用。类加载器按照层级结构组织，形成了一个类加载器树。每个类加载器负责加载特定范围的类，通常分为以下几种类加载器：
**引导类加载器**：它是JVM的一部分，用于加载Java核心类库，通常位于jre/lib/rt.jar中。
**扩展类加载器**：负责加载jre/lib/ext目录下的JAR包。
 **应用程序类加载器**：也称为系统类加载器，负责加载应用程序classpath下的类。
**自定义类加载器**：用户可以根据需要创建自己的类加载器，以加载特定位置或方式的类文件。
**双亲委派模型**是类加载器机制的核心概念之一。它规定了类加载器在尝试加载类时首先委派给父类加载器进行尝试，只有在父类加载器无法加载时才由子类加载器尝试加载。这个模型的目的是确保类的唯一性和安全性。即便是不同的类加载器加载相同的类，它们也会被视为不同的类，因为每个类加载器都有自己的类命名空间。双亲委派模型可以防止系统类库被篡改或替换，因为即使有人尝试加载一个与系统类库同名的类，它也不会覆盖系统类库。

打破双亲委派机制

双亲委派模型通常是由Java虚拟机本身实现和强制执行的，目的是确保类加载的安全性和唯一性。但在某些情况下，你可以通过编写自定义类加载器来打破双亲委派机制。这通常在以下情况下发生：
1. 加载非标准类文件：如果你需要加载非标准的类文件，例如从数据库或网络中动态加载类，传统的双亲委派模型可能无法满足需求，因此你可能需要编写自己的类加载器。
2. 实现类隔离：有时，你可能需要在同一个应用程序中加载多个版本的相同类，或者在不同的模块中加载相同的类，这时自定义类加载器可以帮助你实现类的隔离，防止类冲突。
3. 动态更新类：一些应用程序需要在运行时动态更新类，这也可能需要绕过双亲委派模型，以便能够加载新版本的类。
要打破双亲委派模型，你需要编写自己的类加载器，并覆盖其loadClass方法。在这个方法中，你可以自行决定如何加载类，而不遵循双亲委派规则。通常，你会在自定义类加载器中实现类加载的逻辑，包括从文件系统、网络或其他来源加载类字节码，并使用defineClass方法将类定义加载到JVM中。
需要注意的是，打破双亲委派模型可能会引入类加载的不安全性和不稳定性，因此应该谨慎使用。

垃圾收集器的理解

垃圾收集器是Java虚拟机的一部分，负责管理内存中的对象，以确保内存的有效使用和回收不再使用的对象。以下是对垃圾收集器的理解：
1. 内存管理：垃圾收集器负责管理Java应用程序的堆内存。堆内存是用于存储Java对象的区域，而垃圾收集器负责分配、回收和释放这些内存。
2. 自动回收：垃圾收集器自动识别不再被引用的对象，并将其标记为垃圾，然后释放这些垃圾对象占用的内存。这个过程是自动的，程序员无需手动释放内存。
3. 内存泄漏防止：垃圾收集器可以防止内存泄漏，即程序中的对象无法被回收，导致内存消耗不断增加。通过垃圾收集器，不再使用的对象最终会被回收，释放内存。
4. 性能影响：不同的垃圾收集器实现具有不同的性能特性。一些收集器专注于最小化停顿时间（低延迟），而其他收集器则专注于最大化吞吐量。选择合适的垃圾收集器取决于应用程序的性能需求。
5. 分代垃圾收集：垃圾收集器通常使用分代策略，将堆内存分为不同的代（通常是年轻代和老年代），以便根据对象的生命周期采用不同的回收策略。年轻代通常使用快速的回收算法，而老年代则采用更复杂的算法。
6. 垃圾回收算法：不同的垃圾收集器实现使用不同的垃圾回收算法，如标记-清除、复制、标记-整理等。这些算法有不同的优缺点，适用于不同类型的应用程序。
总之，垃圾收集器是Java内存管理的关键组成部分，它负责自动管理对象的内存，防止内存泄漏，并提供不同的实现和配置选项，以满足不同类型的应用程序的性能需求。

JVM 内存分新生代，老年代，元空间

JVM之所以将内存划分为新生代、老年代和元空间，是为了实现更有效的垃圾回收和提高Java应用程序的性能。这种内存分代的策略基于以下考虑：
1. 对象生命周期不同：
  ○ 大多数对象在被创建后不久就会变得不可达，因此它们的生命周期很短。
  ○ 但也有一些对象具有较长的生命周期，它们可能在应用程序的整个生命周期内存在。
2. 不同的垃圾回收算法：
  ○ 针对不同生命周期的对象，JVM可以使用不同的垃圾回收算法。
  ○ 新生代通常使用复制算法，因为大多数对象很快就会变得不可达。这个算法可以快速回收不再使用的对象。
  ○ 老年代使用标记-清除或标记-整理算法，因为较长生命周期的对象不适合复制算法，需要更复杂的回收策略。
3. 性能优化：
  ○ 分代内存管理有助于提高垃圾回收的性能。由于新生代的对象生命周期短暂，因此垃圾回收发生在新生代的频率较高，但每次回收的内存量较小。
  ○ 老年代的垃圾回收发生频率较低，但每次回收的内存量较大。这减少了垃圾回收的停顿时间，提高了应用程序的响应性能。
4. 内存碎片问题：
  ○ 通过将内存分为新生代和老年代，可以减少内存碎片问题。在新生代中使用复制算法，内存会被分为较小的块，这有助于减少碎片。
  ○ 老年代使用标记-清除或标记-整理算法来处理较长生命周期的对象，进一步减少了碎片。
5. 元数据管理（持久代或元空间）：
  ○ 元数据主要存储在元空间中，将元数据信息单独管理，可以更好地控制和管理类加载和卸载，防止类加载器泄漏和元数据溢出等问题。
总之，分代内存管理是一种有效的策略，可以提高Java应用程序的性能和稳定性，通过根据对象的生命周期和不同的垃圾回收算法来合理管理内存，从而减少垃圾回收的成本和停顿时间，同时降低内存碎片问题。这有助于使Java应用程序更高效地运行。

JVM中一次完整的 GC 流程

JVM中的垃圾回收是自动进行的，它的目标是回收不再使用的对象，释放内存空间，并且保证程序的正常运行。下面是一次完整的GC流程的一般步骤：
1. 标记阶段：GC从根对象开始，通过根对象的引用链，标记所有可达的对象。根对象包括活动线程的栈帧中的局部变量、静态变量、JNI引用等。
2. 垃圾标记：在标记阶段完成后，GC会确定哪些对象是垃圾对象，即不可达对象。这些对象将被标记为垃圾，可以被回收。
3. 垃圾回收：在标记阶段完成后，GC会执行垃圾回收操作，回收被标记为垃圾的对象所占用的内存空间。回收的方式有不同的算法，例如标记-清除、复制、标记-整理等。
4. 内存整理：在垃圾回收完成后，可能会产生内存碎片。为了提高内存的利用率，GC可能会对内存空间进行整理，将存活的对象紧凑地排列在一起，以便更好地分配新的对象。
5. 内存分配：在垃圾回收和内存整理完成后，GC会为新的对象分配内存空间。分配的方式有不同的算法，例如指针碰撞、空闲列表等。
6. 重新分配对象引用：在垃圾回收和内存分配完成后，GC会更新对象之间的引用关系，确保引用指向正确的对象。
以上是一次完整的GC流程的一般步骤。不同的GC算法和实现可能会有所差异，但整体的流程大致相同。GC的目标是回收垃圾对象，释放内存空间，并且尽量减少对应用程序的影响，保证程序的正常运行。

JVM使用元空间替换了永久代

虚拟机使用元空间替代了永久代是因为永久代在过去的实现中存在一些问题和限制，而元空间提供了更好的性能和灵活性。以下是一些详细的原因：
1. 内存管理：永久代的内存管理是由虚拟机自身控制的，无法根据应用程序的需求进行动态调整。而元空间使用本地内存进行管理，可以根据应用程序的需求动态分配和释放内存，提高内存的利用率。
2. 永久代内存溢出：在永久代中，存储类的元数据、常量池、静态变量等，当应用程序加载大量类或者使用大量字符串常量时，可能导致永久代内存溢出。而元空间不再有固定的大小限制，可以根据应用程序的需要自动扩展。
3. 类的卸载：在永久代中，由于类的卸载机制比较复杂，很难实现完全的类卸载。而元空间使用本地内存，可以更容易地实现类的卸载，减少内存的占用。
4. 性能优化：元空间的实现采用了更高效的数据结构和算法，例如使用指针碰撞（Bump the Pointer）的方式分配内存，减少内存碎片化，提高内存分配的效率。此外，元空间还支持并发的类加载和卸载操作，提高了性能。
总的来说，元空间相对于永久代来说具有更好的内存管理、更高的性能和更灵活的特性，能够更好地满足现代应用程序的需求。因此，虚拟机选择使用元空间替代永久代。

TLAB

TLAB是Java虚拟机中的一种优化技术，用于提高对象分配的效率。它是一种线程本地的内存分配缓冲区，每个线程在堆上都有自己独立的TLAB。
在Java中，对象的分配通常是通过在堆上分配内存来完成的。为了提高对象分配的效率，Java虚拟机引入了TLAB机制。TLAB会为每个线程预先分配一块内存空间，线程在分配对象时，会从自己的TLAB中进行分配，而不是直接在堆上进行分配。
TLAB的优点有以下几个：
1. 减少线程同步：由于每个线程都有自己的TLAB，因此不需要进行线程同步操作，可以减少线程竞争和锁的开销。
2. 提高分配速度：由于对象分配是在TLAB中进行的，而不是在堆上进行，因此可以减少对象分配的开销，提高分配速度。
3. 提高局部性：由于每个线程都有自己的TLAB，对象分配在TLAB中进行，可以提高局部性，减少对共享内存的访问，提高缓存命中率。
需要注意的是，TLAB的大小是可以配置的，可以根据实际应用的需求进行调整。过小的TLAB可能会导致频繁的垃圾回收，而过大的TLAB可能会浪费内存空间。
总结来说，TLAB是Java虚拟机中的一种优化技术，用于提高对象分配的效率。每个线程都有自己的TLAB，对象分配在TLAB中进行，可以减少线程同步、提高分配速度和提高局部性。TLAB的大小可以配置，需要根据实际需求进行调整。

安全点

安全点（Safe Point）是指在Java程序执行过程中的某个特定位置，此时所有线程都处于安全状态，即没有执行关键的代码片段，如循环、方法调用等。在安全点上，垃圾回收器可以安全地进行垃圾回收操作，而不会对正在执行的线程产生影响。
为了进行垃圾回收，垃圾回收器需要暂停所有线程的执行，以便检查和回收不再使用的对象。然而，随意中断线程的执行可能会导致程序状态不一致或产生其他问题。因此，在安全点上，所有线程都会停止执行，等待垃圾回收器完成工作后再继续执行。
安全点的选择是由JVM控制的，通常在一些特定的位置上，例如方法调用、循环跳转、异常处理等。当线程达到安全点时，它会停止执行关键代码片段，并等待垃圾回收器完成垃圾回收操作后再继续执行。
安全点的存在可以减少垃圾回收对运行线程的影响，提高垃圾回收的效率。同时，安全点也是实现线程安全的关键之一，确保垃圾回收器和运行线程之间的正确交互。
总而言之，安全点是程序执行过程中的特定位置，用于确保垃圾回收器可以安全地进行垃圾回收操作，而不会对正在执行的线程产生影响。安全点的选择是由垃圾回收器控制的，通常在方法调用、循环跳转、异常处理等关键位置上。

三色标记

三色标记是一种用于并发垃圾收集的算法，常用于分代垃圾收集器中的老年代的垃圾回收过程中。它基于对象的可达性来判断对象是否存活，并标记出存活对象。
三色标记算法将对象分为三种状态：白色、灰色和黑色。
白色表示对象尚未被扫描，即未被标记为存活对象。
灰色表示对象已经被扫描，但其引用的其他对象尚未被扫描。
黑色表示对象已经被扫描，并且其引用的其他对象也已经被扫描。
垃圾收集器在开始垃圾回收时，将所有对象标记为白色。然后从根对象开始，递归地遍历对象图，将遇到的对象标记为灰色，并将其引用的对象添加到待扫描队列中。接着，垃圾收集器从待扫描队列中取出对象，将其标记为黑色，并将其引用的对象添加到待扫描队列中。这个过程会一直进行，直到待扫描队列为空。
最后，所有未被标记为黑色的对象即为垃圾对象，可以被回收。
三色标记算法的优点是可以在并发执行的情况下进行垃圾回收，减少停顿时间。它通过将对象分为三种状态，避免了在并发执行过程中的同时修改和访问对象的冲突。然而，三色标记算法也有一些缺点，如可能存在标记漏标和标记误标的情况，需要额外的处理来解决这些问题。

指针碰撞

在Java中，指针碰撞是一种垃圾收集算法中用于分配内存的一种方式。它通常用于实现停顿时间较短的垃圾收集器，如复制算法和标记-清除算法。
指针碰撞的基本思想是将堆内存分为两个区域：一个是已分配的对象区域，另一个是未分配的空闲区域。通过一个指针来分隔这两个区域。当需要分配对象时，垃圾收集器将对象的大小与空闲区域的大小进行比较，如果空闲区域足够容纳对象，则将指针碰撞指针向前移动对象的大小，并返回指针碰撞指针的旧值作为对象的起始地址。如果空闲区域不足以容纳对象，则进行垃圾回收操作，释放一些内存后再进行分配。
指针碰撞的优点是分配内存的速度很快，只需简单地移动一个指针即可完成。而且由于已分配的对象区域和未分配的空闲区域是连续的，所以内存的利用率也比较高。
然而，指针碰撞算法的缺点是需要保证堆内存的连续性，即堆内存必须是一块连续的内存空间。这对于某些情况下的内存分配来说可能是一个限制，因为连续的内存空间可能会受到碎片化的影响，导致无法分配足够大的对象。因此，在实际应用中，指针碰撞算法通常与其他内存分配算法结合使用，以克服其局限性。