JVM
1.前言
我们开发人员编写的Java代码是怎么让电脑认识的
首先先了解电脑是二进制的系统，他只认识 01010101
比如我们经常要编写 HelloWord.java 电脑是怎么认识运行的
HelloWord.java是我们程序员编写的，我们人可以认识，但是电脑不认识
Java文件编译的过程：
程序员编写的.java文件
由javac编译成字节码文件.class：（为什么编译成class文件，因为JVM只认识.class文件）
在由JVM编译成电脑认识的文件 （对于电脑系统来说 文件代表一切）
Jdk和Jre和JVM的区别
看Java官方的图片，Jdk中包括了Jre，Jre中包括了JVM
JDK = JRE + 开发工具集（例如Javac编译工具等）
JRE = JVM + Java SE 标准类库
2.深入学习JVM
注释：JVM就是Java虚拟机，Java虚拟机就是JVM
2.1 JVM运行时数据区
JVM的运行时数据区是指JVM在运行Java程序时所使用的内存区域，用于存储程序的数据和执行过程中的临时数据，就是我们java运行时的东西是放在那里的
2.1.1 解析JVM运行时数据区
方法区
方法区用于存储类的结构信息，包括类的字节码、常量池、字段和方法的信息等。方法区是被所有线程共享的区域，它在JVM启动时被创建，并在JVM关闭时销毁
Java堆
堆是JVM中最大的一块内存区域，用于存储对象实例和数组。堆是被所有线程共享的区域，它在JVM启动时被创建，并在JVM关闭时销毁。堆被划分为年轻代和老年代，其中年轻代又被划分为Eden区和两个Survivor区
程序计数器
程序计数器用于记录当前线程执行的字节码指令的地址。每个线程都有一个独立的程序计数器，用于控制线程的执行流程
总结：也可以把它叫做线程计数器
例子：在java中最小的执行单位是线程，线程是要执行指令的，执行的指令最终操作的就是我们的电脑，就是 CPU。在CPU上面去运行，有个非常不稳定的因素，叫做调度策略，这个调度策略是时基于时间片的，也就是当前的这一纳秒是分配给那个指令的
假如：线程A在看直播
突然，线程B来了一个视频电话，就会抢夺线程A的时间片，就会打断了线程A，线程A就会挂起
然后，视频电话结束，这时线程A究竟该干什么？
（线程是最小的执行单位，他不具备记忆功能，他只负责去干，那这个记忆就由：程序计数器来记录）
Java虚拟机栈
java虚拟机是线程私有的，它的生命周期和线程相同
虚拟机栈用于存储方法的局部变量、参数、方法调用和返回的信息。每个线程在执行方法时，都会创建一个对应的栈帧，栈帧用于存储方法的局部变量表、操作数栈、动态链接、方法出口等信息
本地方法栈
本地方法栈类似于虚拟机栈，但是它用于执行本地方法（Native Method）的调用和返回
2.2 Java内存结构
上面已经讲了运行时数据区，这里就差几个小组件了
2.2.1 直接内存
直接内存不是虚拟机运行时数据区的一部分，也不是java虚拟机规范中定义的内存区域。但是既然是内存，肯定还是受本机总内存（包括RAM以及SWAP区或者分页文件）大小以及处理器寻址空间的限制
直接内存与堆内存的区别：直接内存申请空间耗费很高的性能，堆内存申请空间耗费比较低
直接内存的IO读写的性能要优于堆内存，在多次读写操作的情况相差非常明显
2.2.2 JVM字节码执行引擎
虚拟机核心的组件就是执行引擎，它负责执行虚拟机的字节码，一般户先进行编译成机器码后执行
"虚拟机"是一个相对于"物理机"的概念，虚拟机的字节码是不能直接在物理机上运行的，需要JVM字节码执行引擎编译成机器码后才可在物理机上执行
2.2.3 垃圾收集系统
程序在运行过程中，会产生大量的内存垃圾（一些没有引用指向的内存对象都属于内存垃圾，因为这些对象已经无法访问，程序用不了它们了，对程序而言它们已经死亡），为了确保程序运行时的性能，java虚拟机在程序运行的过程中不断地进行自动的垃圾回收（GC）
垃圾收集系统是Java的核心，也是不可少的，Java有一套自己进行垃圾清理的机制，开发人员无需手工清理
3.JVM的垃圾回收机制
垃圾回收机制简称GC
GC主要用于Java堆的管理。Java 中的堆是 JVM 所管理的最大的一块内存空间，主要用于存放各种类的实例对象
3.1 什么是垃圾回收机制
程序在运行过程中，会产生大量的内存垃圾（一些没有引用指向的内存对象都属于内存垃圾，因为这些对象已经无法访问，程序用不了它们了，对程序而言它们已经死亡），为了确保程序运行时的性能，java虚拟机在程序运行的过程中不断地进行自动的垃圾回收（GC）
GC是不定时去堆内存中清理不可达对象。不可达的对象并不会马上就会直接回收， 垃圾收集器在一个Java程序中的执行是自动的，不能强制执行清楚那个对象，即使程序员能明确地判断出有一块内存已经无用了，是应该回收的，程序员也不能强制垃圾收集器回收该内存块。程序员唯一能做的就是通过调用System.gc 方法来"建议"执行垃圾收集器，但是他是否执行，什么时候执行却都是不可知的。这也是垃圾收集器的最主要的缺点。当然相对于它给程序员带来的巨大方便性而言，这个缺点是瑕不掩瑜的
3.2 finalize方法作用
finalize()方法是在每次执行GC操作之前时会调用的方法，可以用它做必要的清理工作
它是在Object类中定义的，因此所有的类都继承了它。子类覆盖finalize()方法以整理系统资源或者执行其他清理工作。finalize()方法是在垃圾收集器删除对象之前对这个对象调用的
java
package com.lijie;
public class Test {
public static void main(String[] args) {
Test test = new Test();
test = null;
System.gc(); // 手动回收垃圾
}
@Override
protected void finalize() throws Throwable {
// gc回收垃圾之前调用
System.out.println("gc回收垃圾之前调用的方法");
}
}3.3 新生代、老年代、永久代(方法区)的区别
Java 中的堆是 JVM 所管理的最大的一块内存空间，主要用于存放各种类的实例对象
在 Java 中，堆被划分成两个不同的区域：新生代 ( Young )、老年代 ( Old )
老年代就一个区域。新生代 ( Young ) 又被划分为三个区域：Eden、From Survivor、To Survivor，这样划分的目的是为了使 JVM 能够更好的管理堆内存中的对象，包括内存的分配以及回收
永久代就是JVM的方法区。在这里都是放着一些被虚拟机加载的类信息，静态变量，常量等数据。这个区中的东西比老年代和新生代更不容易回收。
3.3.1 为什么要这样分代
其实主要原因就是可以根据各个年代的特点进行对象分区存储，更便于回收，采用最适当的收集算法：
新生代中，每次垃圾收集时都发现大批对象死去，只有少量对象存活，便采用了复制算法，只需要付出少量存活对象的复制成本就可以完成收集
而老年代中因为对象存活率高、没有额外空间对它进行分配担保，就必须采用"标记-清理"或者"标记-整理"算法
3.4 如何判断对象是否存活
3.4.1 引用计数法
引用计数法就是如果一个对象没有被任何引用指向，则可视之为垃圾。这种方法的缺点就是不能检测到环的存在
首先需要声明，至少主流的Java虚拟机里面都没有选用引用计数算法来管理内存
什么是引用计数法：每个对象在创建的时候，就给这个对象绑定一个计数器。每当有一个引用指向该对象时，计数器加一；每当有一个指向它的引用被删除时，计数器减一。这样，当没有引用指向该对象时，计数器为0就代表该对象死亡
引用计数法的优点：引用计数算法的实现简单，判定效率也很高，在大部分情况下它都是一个不错的算法引用计数法的缺点：主流的Java虚拟机里面没有选用引用计数算法来管理内存，其中最主要的原因是它很难解决对象之间相互循环引用的问题
3.4.2 可达性分析法
该种方法是从GC Roots开始向下搜索，搜索所走过的路径为引用链。当一个对象到GC Roots没用任何引用链时，则证明此对象是不可用的，表示可以回收
上图上图中Object1、Object2、Object3、Object4、Object5到GC Roots是可达的，表示它们是有引用的对象，是存活的对象不可以进行回收
Object6、Object7、Object8虽然是互相关联的，但是它们到GC Roots是不可达的，所以他们是可以进行回收的对象
那些可以作为GC Roots 的对象：1.虚拟机栈（栈帧中的本地变量表）中引用的对象
2.方法区中类静态属于引用的对象
3.方法区中常量引用的对象
4.本地方法栈中JNI（即一般说的Native方法）引用的对象
可达性算法的优点：解决相互循环引用问题可达性算法的优点：目前和引用计数法比没得缺点
可达性算法的应用场景：这是目前主流的虚拟机都是采用的算法
3.5 垃圾回收机制策略（也称为GC的算法）
3.5.1 引用计数算法
每个对象在创建的时候，就给这个对象绑定一个计数器。每当有一个引用指向该对象时，计数器加一；每当有一个指向它的引用被删除时，计数器减一。这样，当没有引用指向该对象时，计数器为0就代表该对象死亡，这时就应该对这个对象进行垃圾回收操作
引用计数法的优点：引用计数算法的实现简单，判定效率也很高引用计数法的缺点：主流的Java虚拟机里面没有选用引用计数算法来管理内存，其中最主要的原因是它很难解决对象之间相互循环引用的问题
引用计数法的应用场景：建议不要用
3.5.2 标记--清除算法
为每个对象存储一个标记位，记录对象的状态（活着或是死亡）
分为两个阶段，一个是标记阶段，这个阶段内，为每个对象更新标记位，检查对象是否死亡；第二个阶段是清除阶段，该阶段对死亡的对象进行清除，执行 GC 操作
标记清除算法的优点：是可以解决循环引用的问题
必要时才回收(内存不足时)
标记清除算法的缺点：标记和清除的效率不高，尤其是要扫描的对象比较多的时候
会造成内存碎片(会导致明明有内存空间,但是由于不连续,申请稍微大一些的对象无法做到)
标记清除算法的应用场景：该算法一般应用于老年代,因为老年代的对象生命周期比较长
3.5.3 标记--整理算法
标记清除算法和标记压缩算法非常相同，但是标记压缩算法在标记清除算法之上解决内存碎片化（有些人叫"标记整理算法"为"标记压缩算法"）
标记-整理法是标记-清除法的一个改进版。同样，在标记阶段，该算法也将所有对象标记为存活和死亡两种状态；不同的是，在第二个阶段，该算法并没有直接对死亡的对象进行清理，而是将所有存活的对象整理一下，放到另一处空间，然后把剩下的所有对象全部清除。这样就达到了标记-整理的目的
标记--整理算法优点：解决标记清除算法出现的内存碎片问题
标记--整理算法缺点：压缩阶段，由于移动了可用对象，需要去更新引用
标记--整理算法应用场景：该算法一般应用于老年代,因为老年代的对象生命周期比较长
3.5.4 复制算法
该算法将内存平均分成两部分，然后每次只使用其中的一部分，当这部分内存满的时候，将内存中所有存活的对象复制到另一个内存中，然后将之前的内存清空，只使用这部分内存，循环下去
这个算法与标记-整理算法的区别在于，该算法不是在同一个区域复制，而是将所有存活的对象复制到另一个区域内
复制算法的优点：在存活对象不多的情况下，性能高，能解决内存碎片和java垃圾回收算法之-标记清除 中导致的引用更新问题
复制算法的缺点：:会造成一部分的内存浪费。不过可以根据实际情况，将内存块大小比例适当调整；如果存活对象的数量比较大，复制算法的性能会变得很差
复制算法的应用场景：复制算法一般是使用在新生代中，因为新生代中的对象一般都是朝生夕死的，存活对象的数量并不多，这样使用复制算法进行拷贝时效率比较高
4.垃圾收集器
4.1 什么是垃圾收集器？
垃圾收集器是垃圾回收算法（引用计数法、标记清楚法、标记整理法、复制算法）的具体实现，不同垃圾收集器、不同版本的JVM所提供的垃圾收集器可能会有很在差别
图中展示了7种不同分代的收集器：Serial、ParNew、Parallel Scavenge、CMS、Serial Old、Parallel Old、G1
而它们所处区域，则表明其是属于新生代还是老年代的收集器：新生代收集器：Serial、ParNew、Parallel Scavenge
老年代收集器：CMS、Serial Old、Parallel Old
整堆收集器：G1
4.2 垃圾回收器详解
5.JVM参数配置
5.1 JVM内存参数简述
常用的设置
-Xms：初始堆大小，JVM 启动的时候，给定堆空间大小。
-Xmx：最大堆大小，JVM 运行过程中，如果初始堆空间不足的时候，最大可以扩展到多少
-Xss：设置每个线程的堆栈大小。JDK5后每个线程 Java 栈大小为 1M，以前每个线程堆栈大小为 256K
-XX:ThreadStackSize=n 线程堆栈大小
-XX:PermSize=n 设置持久代初始值
-XX:MaxPermSize=n 设置持久代大小
5.2 JVM参数在哪设置
5.2.1 IDEA在哪里设置JVM参数
1.单个项目的应用
2.全局的配置
找到IDEA安装目录中的bin目录
找到idea.exe.vmoptions文件
打开该文件编辑并保存
5.2.2 Jar包在哪里设置JVM参数
Jar包简单，一般都是SpringBoot项目打成Jar包来运行
java
#运行时java -jar是直接插入JVM命令就好了
java -Xms1024m -Xmx1024m ...等等等 JVM参数 -jar springboot_app.jar & 5.3 调优总结
1.在实际工作中，我们可以直接将初始的堆大小与最大堆大小相等，这样的好处是可以减少程序运行时垃圾回收次数，从而提高效率
2.初始堆值和最大堆内存内存越大，吞吐量就越高，但是也要根据自己电脑(服务器)的实际内存来比较
3.最好使用并行收集器,因为并行收集器速度比串行吞吐量高，速度快，当然，服务器一定要是多线程的
4.设置堆内存新生代的比例和老年代的比例最好为1:2或者1:3，默认的就是1:2
5.减少GC对老年代的回收。设置生代带垃圾对象最大年龄，进量不要有大量连续内存空间的java对象，因为会直接到老年代，内存不够就会执行GC
注释：其实最主要的还是服务器要好，你硬件都跟不上，软件再好都没用注释：老年代GC很慢，新生代没啥事
注释：默认的JVM堆大小好像是电脑实际内存的四分之一左右，
6.类加载器
6.1 类加载的机制及过程
程序主动使用某个类时，如果该类还未被加载到内存中，则JVM会通过加载、连接、初始化3个步骤来对该类进行初始化。如果没有意外，JVM将会连续完成3个步骤，所以有时也把这个3个步骤统称为类加载或类初始化
1.加载
加载指的是将类的class文件读入到内存，并将这些静态数据转换成方法区中的运行时数据结构，并在堆中生成一个代表这个类的java.lang.Class对象，作为方法区类数据的访问入口，这个过程需要类加载器参与
类加载的最终产物就是位于堆中的Class对象（注意不是目标类对象），该对象封装了类在方法区中的数据结构，并且向用户提供了访问方法区数据结构的接口，即Java反射的接口
2.连接过程
当类被加载之后，系统为之生成一个对应的Class对象，接着将会进入连接阶段，连接阶段负责把类的二进制数据合并到JRE中（意思就是将java类的二进制代码合并到JVM的运行状态之中）。类连接又可分为如下3个阶段
验证：确保加载的类信息符合JVM规范，没有安全方面的问题。主要验证是否符合Class文件格式规范，并且是否能被当前的虚拟机加载处理
准备：正式为类变量（static变量）分配内存并设置类变量初始值的阶段，这些内存都将在方法区中进行分配
解析：虚拟机常量池的符号引用替换为字节引用过程
3.初始化
初始化阶段是执行类构造器() 方法的过程。类构造器()方法是由编译器自动收藏类中的所有类变量的赋值动作和静态语句块(static块)中的语句合并产生，代码从上往下执行
当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化
虚拟机会保证一个类的() 方法在多线程环境中被正确加锁和同步
总结就是：初始化是为类的静态变量赋予正确的初始值
6.2 类加载器的介绍
启动（Bootstrap）类加载器
扩展（Extension）类加载器
系统类加载器
自定义加载器
6.2.1 根类加载器（bootstrap class loader）
它用来加载 Java 的核心类，是用原生代码来实现的，并不继承自 java.lang.ClassLoader（负责加载$JAVA_HOME中jre/lib/rt.jar里所有的class，由C++实现，不是ClassLoader子类）。由于引导类加载器涉及到虚拟机本地实现细节，开发者无法直接获取到启动类加载器的引用，所以不允许直接通过引用进行操作
6.2.2 扩展类加载器（extensions class loader）
扩展类加载器是指Sun公司实现的sun.misc.Launcher$ExtClassLoader类，由Java语言实现的，是Launcher的静态内部类，它负责加载<JAVA_HOME>/lib/ext目录下或者由系统变量-Djava.ext.dir指定位路径中的类库，开发者可以直接使用标准扩展类加载器
6.2.3 系统类加载器（system class loader）
被称为系统（也称为应用）类加载器，它负责在JVM启动时加载来自Java命令的-classpath选项、java.class.path系统属性，或者CLASSPATH换将变量所指定的JAR包和类路径。程序可以通过ClassLoader的静态方法getSystemClassLoader()来获取系统类加载器
如果没有特别指定，则用户自定义的类加载器都以此类加载器作为父加载器。由Java语言实现，父类加载器为ExtClassLoader。（Java虚拟机采用的是双亲委派模式即把请求交由父类处理，它一种任务委派模式，）
6.3 理解双亲委派模式
双亲委派机制，其工作原理的是，如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行，如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器，如果父类加载器可以完成类加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，这就是双亲委派模式，即每个儿子都很懒，每次有活就丢给父亲去干，直到父亲说这件事我也干不了时，儿子自己才想办法去完成
双亲委派机制的优势：采用双亲委派模式的是好处是Java类随着它的类加载器一起具备了一种带有优先级的层次关系，通过这种层级关可以避免类的重复加载，当父亲已经加载了该类时，就没有必要子ClassLoader再加载一次。其次是考虑到安全因素，java核心api中定义类型不会被随意替换，假设通过网络传递一个名为java.lang.Integer的类，通过双亲委托模式传递到启动类加载器，而启动类加载器在核心Java API发现这个名字的类，发现该类已被加载，并不会重新加载网络传递的过来的java.lang.Integer，而直接返回已加载过的Integer.class，这样便可以防止核心API库被随意篡改
7.JVM可视化工具
7.1为什么要可视化工具
开发大型 Java 应用程序的过程中难免遇到内存泄露、性能瓶颈等问题，比如文件、网络、数据库的连接未释放，未优化的算法等。随着应用程序的持续运行，可能会造成整个系统运行效率下降，严重的则会造成系统崩溃。为了找出程序中隐藏的这些问题，在项目开发后期往往会使用性能分析工具来对应用程序的性能进行分析和优化
7.2 visualVm
VisualVM 是一款免费的，集成了多个 JDK 命令行工具的可视化工具，它能为您提供强大的分析能力，对 Java 应用程序做性能分析和调优。这些功能包括生成和分析海量数据、跟踪内存泄漏、监控垃圾回收器、执行内存和 CPU 分析，同时，它能自动选择更快更轻量级的技术尽量减少性能分析对应用程序造成的影响，提高性能分析的精度
他作为Oracle JDK 的一部分，位于 JDK 根目录的 bin 文件夹下。VisualVM 自身要在 JDK6 以上的版本上运行，但是它能够监控 JDK1.4 以上版本的应用程序
7.2.1 打开visualVm
位于 JDK 根目录的 bin 文件夹下的jvisualvm.exe
7.2.2 本地测试项目JVM运行状态
我这本地有了好几个进程，这是我IDea工具的
我运行一个SpringBoot项目
此时就开始监控了
7.3 jconsole
从Java 5开始 引入了 JConsole。JConsole 是一个内置 Java 性能分析器，可以从命令行或在 GUI shell 中运行。您可以轻松地使用 JConsole（或者，它更高端的 "近亲" VisualVM ）来监控 Java 应用程序性能和跟踪 Java 中的代码
7.3.1 启动JConsole
点击jdk/bin 目录下面的jconsole.exe 即可启动,然后会自动自动搜索本机运行的所有虚拟机进程。选择其中一个进程可开始进行监控
远程连接项目也很简单，和 visualVm基本一致，可以自己研究一下
JVM 原理及优化面试题
1.说一下JVM的主要组成部分及其作用
1.类加载器：负责将Java字节码文件加载到内存中，并转换为JVM可以执行的形式，包括引导类加载器、扩展类加载器和应用程序类加载器
执行引擎：执行引擎负责解释和执行Java字节码指令。它可以将字节码转换为机器码，并进行实际的执行
运行时数据区：JVM用来存储程序运行期间的数据的区域。主要包括方法区、堆、虚拟机栈、本地方法栈和程序计数器
垃圾回收器：垃圾回收器负责自动回收不再使用的对象和释放内存空间。它通过标记-清除、复制、标记-整理等算法来回收垃圾对象
JIT编译器：它可以将热点代码（经常执行的代码）转换为本地机器码，以提高程序的执行效率
本地方法接口：本地方法接口允许Java程序调用本地的C、C++或其他语言编写的代码。通过本地方法接口，Java程序可以与底层系统进行交互
JVM的主要作用是提供一个跨平台的运行环境，使得Java程序可以在不同的操作系统上运行。它负责加载、解释和执行Java字节码，并提供垃圾回收、内存管理、线程管理等功能。JVM通过虚拟化技术，将Java程序与底层的硬件和操作系统隔离开来，提供了高度可移植性和安全性
2.说一下JVM运行时数据区
JVM的运行时数据区是指JVM在运行Java程序时所使用的内存区域，用于存储程序的数据和执行过程中的临时数据
方法区（Method Area）：方法区用于存储类的结构信息，包括类的字节码、常量池、字段和方法的信息等。方法区是被所有线程共享的区域，它在JVM启动时被创建，并在JVM关闭时销毁
堆（Heap）：堆是JVM中最大的一块内存区域，用于存储对象实例和数组。堆是被所有线程共享的区域，它在JVM启动时被创建，并在JVM关闭时销毁。堆被划分为年轻代和老年代，其中年轻代又被划分为Eden区和两个Survivor区
虚拟机栈：虚拟机栈用于存储方法的局部变量、参数、方法调用和返回的信息。每个线程在执行方法时，都会创建一个对应的栈帧，栈帧用于存储方法的局部变量表、操作数栈、动态链接、方法出口等信息
本地方法栈：本地方法栈类似于虚拟机栈，但是它用于执行本地方法的调用和返回
程序计数器：程序计数器用于记录当前线程执行的字节码指令的地址。每个线程都有一个独立的程序计数器，用于控制线程的执行流程
运行时常量池：用于存储编译时生成的字面量和符号引用。运行时常量池可以动态地扩展和缩小
这些运行时数据区在JVM启动时被创建，并在JVM关闭时销毁，它们共同支持Java程序的正常运行和内存管理
3.深拷贝和浅拷贝
浅拷贝：浅拷贝是指创建一个新对象，将原对象的值复制到新对象中，但是新对象和原对象共享相同的内存地址。也就是说浅拷贝只会复制引用，不会复制引用指向的对象。因此，修改新对象中的引用类型成员变量会影响原对象中的引用类型成员变量
深拷贝：深拷贝是指创建一个新对象，将原对象的值复制到新对象中，并且新对象和原对象拥有独立的内存地址。也就是说，深拷贝会递归地复制引用类型的成员变量，使得新对象和原对象的引用类型成员变量指向不同的对象
对于浅拷贝，可以使用Object类的clone()方法来实现。需要注意的是，被拷贝的类必须实现Cloneable接口，并重写clone()方法
对于深拷贝，可以通过实现Serializable接口，将对象序列化为字节流，然后再将字节流反序列化为对象。这样可以创建一个新的对象，而不是复制引用
4.对象的创建流程
1.类加载：在使用一个类之前，需要先加载该类的字节码文件。类加载过程包括加载、连接和初始化三个阶段。加载阶段将字节码文件加载到内存中，连接阶段包括验证、准备和解析等操作，初始化阶段执行类的静态初始化代码
2.分配内存：在类加载完成后，Java虚拟机会为对象在堆中分配内存空间。内存的分配方式可以是指针碰撞或空闲列表
3.初始化零值：在分配内存后，Java虚拟机会将对象的实例变量设置为零值（对于基本数据类型）或者null（对于引用类型）
4.设置对象头：Java对象在内存中有一个对象头，用于存储对象的元数据信息，如哈希码、GC标记、锁状态等
5.执行构造函数：在对象头设置完成后，Java虚拟机会调用对象的构造函数，对实例变量进行初始化操作。构造函数是对象创建过程中的最后一步
6.返回对象引用：对象创建完成后，Java虚拟机会返回对象的引用，这个引用可以被赋值给变量，或者作为参数传递给其他方法
需要注意的是，对象的创建过程是由Java虚拟机自动完成的，程序员无需手动管理内存分配和对象初始化的过程
5.jvm如何为对象分配内存
在Java虚拟机中，对象的内存分配是通过堆来实现的
1.确定对象的类型：在分配内存之前，首先需要确定对象的类型，即确定所需的内存大小和布局
2.计算对象的大小：根据对象的类型，计算出对象所需的内存大小。这个大小包括对象头和实例数据两部分。
3.分配内存空间：在堆中找到一块足够大小的连续内存空间，用来存储对象
4.设置对象头：在分配的内存空间中，设置对象头部分的数据。对象头包括一些元信息，如对象的哈希码、锁状态、GC标记等
5.初始化实例数据：将对象的实例数据进行初始化，即将成员变量赋予初始值
6.返回对象引用：返回对象的引用，使得程序可以通过引用来操作对象
6.jvm如何处理并发安全问题
Java虚拟机（JVM）处理并发安全问题的主要方式是通过线程同步和内存模型来保证多线程程序的正确性
1.线程同步：JVM提供了多种线程同步机制，如synchronized关键字、Lock接口、volatile关键字等。这些机制可以保证多个线程对共享数据的访问是有序的，避免了数据竞争和不一致的情况
2.内存模型：JVM定义了一套内存模型，即Java内存模型（Java Memory Model，JMM）。JMM规定了多线程程序中各个线程之间如何进行内存交互，包括可见性、原子性和有序性等方面的规则。通过遵守JMM的规则，可以保证多线程程序的正确性
3.原子操作：JVM提供了一些原子操作，比如CAS（Compare and Swap）指令，它可以保证对共享数据的操作是原子的，不会被其他线程干扰
4.锁优化：JVM对锁进行了优化，如偏向锁、轻量级锁和重量级锁等。这些优化技术可以减少锁的竞争，提高并发性能
7.对象的访问定位
在Java虚拟机中，对象的访问定位主要包括两个过程：对象的引用定位和对象的访问定位
对象的引用定位：当程序中需要访问一个对象时，首先需要获取该对象的引用。在Java虚拟机中，对象的引用可以通过栈或者堆中的对象来获取。栈中保存了对象的引用，而堆中保存了对象的实例数据
对象的访问定位：一旦获取了对象的引用，就可以通过引用来访问对象的实例数据。在Java虚拟机中，对象的实例数据存储在堆中，通过对象的引用可以定位到堆中的相应对象，并访问其实例数据
需要注意的是，在Java虚拟机中，对象的访问定位是动态的。即对象的引用和实例数据可能会发生变化，而Java虚拟机会根据引用的变化自动调整对象的访问定位。例如，当对象被移动到新的内存空间时，Java虚拟机会自动更新对象的引用，以便正确访问对象的实例数据
8.Java中是否存在内存泄漏
是的，Java中也存在内存泄漏的问题。内存泄漏指的是程序中的一块内存被分配后，由于某种原因没有被释放，导致这块内存无法再被程序使用，最终导致内存的浪费
1.对象的引用未被及时释放：如果一个对象不再被使用，但其引用仍然存在，那么垃圾回收器将无法回收该对象所占用的内存，从而导致内存泄漏
2.集合类未正确使用：如果使用集合类时，没有正确地移除不再需要的元素，那么这些元素将一直占用内存，导致内存泄漏。
3.资源未正确释放：如果程序使用了一些需要手动释放的资源（如文件、数据库连接、网络连接等），但程序没有正确释放这些资源，就会导致内存泄漏
4.静态集合类的使用：如果在静态集合类中存储了大量的对象，并且这些对象在程序运行过程中不会被移除，那么这些对象将一直占用内存，导致内存泄漏
为了避免内存泄漏，可以采取以下措施：
及时释放对象的引用，确保不再使用的对象能够被垃圾回收器回收
在使用集合类时，注意及时移除不再需要的元素
对于需要手动释放的资源，使用try-with-resources或者finally块来确保资源的正确释放
避免过度使用静态集合类，确保只存储必要的对象
9.简述Java垃圾回收机制
Java垃圾回收机制是自动管理内存的一种机制，它负责在运行时自动释放不再使用的对象，以便回收内存空间并提高系统性能
1.对象的创建和内存分配：当使用关键字 new 创建一个对象时，Java虚拟机（JVM）会在堆内存中为该对象分配内存空间。
2.对象的引用：对象在内存中的地址被保存在引用变量中。如果一个对象被引用变量引用，那么它就是可达的
3.标记过程：JVM通过垃圾回收器来标记所有可达的对象。垃圾回收器会从根对象（如全局变量、静态变量等）开始，递归地遍历所有可达对象，并将它们标记为活动对象
4.垃圾对象的识别：在标记过程之后，未被标记的对象就被认为是垃圾对象，可以被回收
5.垃圾回收：JVM的垃圾回收器会对垃圾对象进行回收，释放它们所占用的内存空间。垃圾回收器使用不同的算法来回收内存，如标记-清除、复制、标记-整理等
6.内存回收后的内存整理：在垃圾回收后，可能会出现内存碎片化的情况。为了解决这个问题，某些垃圾回收器会对内存进行整理，将存活的对象向一端移动，以便在另一端创建连续的内存块
10.什么是GC|垃圾回收器基本原理
GC（Garbage Collection）是指垃圾回收的缩写，是Java虚拟机（JVM）中的一种自动内存管理机制。GC的基本原理是通过检测和回收不再使用的对象，释放它们所占用的内存空间，以便重新利用
垃圾回收器是实现GC的具体实现，它负责执行垃圾回收的算法和策略。常见的垃圾回收算法包括标记-清除、复制、标记-整理等。垃圾回收器会从根对象（如全局变量、静态变量等）开始，递归地遍历所有可达对象，并将可达对象标记为活动对象，未被标记的对象即为垃圾对象，可以被回收
垃圾回收并不是立即回收内存的，而是在JVM认为需要回收内存时才进行。JVM会根据一些策略和条件来判断是否需要进行垃圾回收，如内存占用超过一定阈值、系统空闲时间等。一般情况下，垃圾回收器会在内存不足时才会触发回收操作
在Java中，程序员无法主动通知虚拟机回收垃圾。垃圾回收是由JVM自动管理的，程序员只需要确保不再使用的对象没有被引用，并且没有其他引用指向它们，垃圾回收器会在适当的时候自动回收这些对象。程序员可以通过手动将对象的引用置为null来帮助垃圾回收器判断对象是否可回收
11.Java中有哪些引用类型|有什么区别|使用场景
Java中有四种引用类型：强引用、软引用、弱引用和虚引用
1.强引用：
强引用是最常见的引用类型，通过关键字new创建的对象都是强引用
强引用指向的对象在任何时候都不会被垃圾回收器回收，只有在没有任何强引用指向该对象时，垃圾回收器才会回收该对象
2.软引用：
软引用是用来描述一些还有用但非必需的对象
当内存不足时，垃圾回收器会尝试回收软引用指向的对象，但不保证一定会回收
软引用主要用于缓存、图片缓存等需要在内存不足时释放内存的场景
3.弱引用：
弱引用用于描述非必需对象，比软引用更弱，更容易被垃圾回收器回收
当垃圾回收器运行时，无论内存是否足够，都会回收弱引用指向的对象
弱引用主要用于解决内存泄漏问题，如缓存、监听器等
4.虚引用：
虚引用是最弱的一种引用类型，几乎没有实际用途
虚引用的主要作用是跟踪对象被垃圾回收的状态
虚引用必须与引用队列（ReferenceQueue）一起使用，当对象被垃圾回收时，会将虚引用加入引用队列中
5.使用场景：
强引用适用于需要确保对象一直存在的场景
软引用适用于需要在内存不足时释放内存的场景
弱引用适用于解决内存泄漏问题的场景
虚引用几乎没有实际用途，一般不会直接使用
12.如何判断对象是否可以被回收|对象什么时候可以被垃圾回收
在Java中，判断对象是否可以被回收主要依赖于垃圾回收器进行的算法和策略。一般情况下，对象可以被垃圾回收的条件如下：
1.引用计数为0：当对象的引用计数为0时，表示没有任何强引用指向该对象，即没有任何途径可以访问该对象，可以被回收
2.可达性分析：通过可达性分析算法，垃圾回收器会从根对象（如全局变量、静态变量等）开始，递归地遍历所有可达对象，并将活动对象标记为活动对象，未被标记的对象即为垃圾对象，可以被回收
对象什么时候可以被垃圾回收取决于垃圾回收器的具体实现和策略，一般情况下，垃圾回收器会在以下情况下回收对象：
1.内存不足：当系统内存不足时，垃圾回收器会被触发，回收不再使用的对象来释放内存空间
2.系统空闲时间：当系统处于空闲状态时，垃圾回收器可能会被触发，回收不再使用的对象
3.手动调用System.gc()：虽然程序员无法主动通知虚拟机回收垃圾，但可以通过调用System.gc()方法来建议垃圾回收器执行回收操作。但是，垃圾回收器是否真正执行回收操作仍然取决于具体的实现和策略。一般情况下，不建议频繁调用System.gc()，因为过度的垃圾回收会影响系统性能
13.JVM中有哪些垃圾回收器
1.标记-清除算法（Mark and Sweep）：该算法分为两个阶段，首先标记出所有活动对象，然后清除所有未标记的对象。该算法的缺点是会产生大量的内存碎片
2.复制算法（Copying）：该算法将内存分为两个区域，每次只使用其中一个区域。活动对象被复制到另一个区域，然后将当前区域中的所有对象一次性清除。该算法的优点是简单高效，但会浪费一部分内存
3.标记-压缩算法（Mark and Compact）：该算法首先标记出所有活动对象，然后将它们压缩到内存的一端，清除掉其他未使用的内存。该算法解决了标记-清除算法产生的内存碎片问题
4.分代算法（Generational）：该算法将内存分为不同的代，一般分为年轻代和老年代。年轻代使用复制算法，老年代使用标记-压缩算法。根据对象的生命周期，将对象分配到不同的代中，可以更加高效地进行垃圾回收
5.并发标记算法（Concurrent Marking）：该算法在垃圾回收的同时允许程序继续运行，减少了垃圾回收对程序的影响。常见的并发标记算法有CMS（Concurrent Mark Sweep）和G1（Garbage-First）算法
14.新生代|老年代回收器有哪些|区别
在Java虚拟机中，新生代和老年代是内存分代的概念，用于区分对象的生命周期和垃圾回收的策略
新生代回收器：
1.Serial收集器：采用复制算法，单线程进行垃圾回收，适用于单核CPU或小内存的环境。
2.ParNew收集器：Serial收集器的多线程版本，适用于多核CPU的环境
老年代回收器：
1.Serial Old收集器：采用标记-压缩算法，单线程进行垃圾回收，适用于单核CPU或小内存的环境
2.Parallel Old收集器：Serial Old收集器的多线程版本，适用于多核CPU的环境
3.CMS收集器：采用标记-清除算法，并发进行垃圾回收，允许应用程序和垃圾回收线程并发执行
4.G1收集器：将整个堆内存划分为多个区域，采用标记-复制算法和标记-整理算法，适用于大内存的应用程序
区别：
1.新生代回收器主要用于回收新生代的对象，而老年代回收器主要用于回收老年代的对象
2.新生代回收器通常采用复制算法，将存活的对象复制到另一个区域，而老年代回收器通常采用标记-压缩、标记-清除或者标记-整理算法
3.新生代回收器一般需要停止应用程序的执行，进行垃圾回收操作，而老年代回收器通常可以与应用程序并发执行，减少停顿时间
4.新生代回收器的目标是尽快回收短命对象，减少对象在新生代的存活时间，而老年代回收器的目标是减少老年代的碎片和垃圾对象
15.详细介绍一下CMS垃圾回收器
CMS（Concurrent Mark Sweep）是Java虚拟机中的一种垃圾回收器，它主要用于回收老年代的对象。与传统的垃圾回收器不同，CMS垃圾回收器采用了并发的方式进行垃圾回收，可以与应用程序并发执行，减少停顿时间
CMS垃圾回收器的工作过程包括以下几个阶段：
1.初始标记：在这个阶段，CMS垃圾回收器会暂停应用程序的执行，标记出所有根对象和直接可达的对象，以建立起一个"安全"点
2.并发标记：在初始标记之后，CMS垃圾回收器会与应用程序并发执行，标记出所有从根对象可达的对象。这个阶段的标记是并发的，不会停顿应用程序的执行
3.重新标记：在并发标记之后，CMS垃圾回收器会再次暂停应用程序的执行，处理在并发标记期间发生的引用变化，重新标记出所有的存活对象
4.并发清除：在重新标记之后，CMS垃圾回收器会与应用程序并发执行，清除所有标记为可回收的对象。这个阶段的清除是并发的，不会停顿应用程序的执行
CMS垃圾回收器的优点是可以与应用程序并发执行，减少停顿时间，适用于对响应时间要求较高的应用程序。然而，由于CMS垃圾回收器的并发执行，会占用一部分CPU资源，可能会导致应用程序的吞吐量下降。此外，CMS垃圾回收器在清除过程中可能会产生空间碎片，需要进行碎片整理
需要注意的是，CMS垃圾回收器在执行过程中会产生一些停顿时间，尽管这些停顿时间相对于传统的垃圾回收器较短，但仍然可能会影响到应用程序的响应性能。在一些特殊场景下，如果应用程序对停顿时间非常敏感，可能需要考虑其他的垃圾回收器选项。
16.G1垃圾回收器
是Java虚拟机中的一种垃圾回收器，它主要用于回收堆内存中的对象。与传统的垃圾回收器不同，G1垃圾回收器采用了分代收集和区域化管理的策略，可以更加高效地回收堆内存中的垃圾对象
G1垃圾回收器的工作过程包括以下几个阶段：
1.初始标记：在这个阶段，G1垃圾回收器会暂停应用程序的执行，标记出所有根对象和直接可达的对象，以建立起一个"安全"点
2.并发标记：在初始标记之后，G1垃圾回收器会与应用程序并发执行，标记出所有从根对象可达的对象。这个阶段的标记是并发的，不会停顿应用程序的执行
3.最终标记：在并发标记之后，G1垃圾回收器会再次暂停应用程序的执行，处理在并发标记期间发生的引用变化，重新标记出所有的存活对象
4.筛选回收：在最终标记之后，G1垃圾回收器会根据各个区域中存活对象的数量和回收目标来选择回收的区域。它会优先回收包含垃圾最多的区域，即"Garbage-First"的策略
5.并发清理：在筛选回收之后，G1垃圾回收器会与应用程序并发执行，清理所有标记为可回收的对象。这个阶段的清理是并发的，不会停顿应用程序的执行
G1垃圾回收器的优点是可以更加高效地回收堆内存中的垃圾对象，减少停顿时间，并且可以根据应用程序的需求进行灵活的堆内存分配和回收。它适用于具有大堆内存和对响应时间要求较高的应用程序。此外，G1垃圾回收器还可以一定程度上解决传统垃圾回收器中产生的空间碎片问题
需要注意的是，G1垃圾回收器在执行过程中可能会占用一部分CPU资源，可能会导致应用程序的吞吐量下降。此外，G1垃圾回收器的配置参数较多，需要根据应用程序的特点进行合理的调优。
17.分代垃圾回收器如何工作
分代垃圾回收器是一种常用的垃圾回收算法，它将堆内存分为不同的代，每个代都有不同的生命周期和回收策略。一般来说，堆内存被分为新生代和老年代两个部分
新生代：新生代是用于存放新创建的对象的区域。当一个对象被创建时，它会被分配到新生代的Eden区域。当Eden区域满了之后，会触发一次Minor GC（新生代垃圾回收），将存活的对象复制到Survivor区域。Survivor区域也会随着时间的推移，存放多次复制后仍然存活的对象。当Survivor区域满了之后，存活的对象会被复制到另一个Survivor区域，同时清空原来的Survivor区域。经过多次Minor GC后，仍然存活的对象会被晋升到老年代
老年代：老年代是用于存放长时间存活的对象的区域。当老年代空间不足时，会触发一次Major GC（老年代垃圾回收），对整个堆内存进行回收。Major GC的成本较高，会导致较长的停顿时间
分代垃圾回收器的工作原理是基于观察到的现象：大部分对象的生命周期都很短暂，而只有少部分对象会长时间存活。因此，将堆内存分为新生代和老年代，采用不同的回收策略，可以提高垃圾回收的效率
18.Java内存分配|回收策略
Java内存分配：Java虚拟机的堆内存主要用于存放对象实例。在Java中，堆内存的分配是动态的，由Java虚拟机自动管理。Java堆内存被划分为新生代和老年代，其中新生代又被划分为Eden区、Survivor区1和Survivor区2
回收策略：Java虚拟机的垃圾回收器根据对象的存活时间和分代进行不同的回收策略。一般来说，新生代使用复制算法进行垃圾回收，老年代使用标记-清除-整理算法进行垃圾回收。此外，还有一些特殊的垃圾回收算法，如增量式垃圾回收、并发垃圾回收
19.Java类加载机制|类加载机制原理
Java类加载机制是Java虚拟机在运行时将类的字节码加载到内存并转换为Java对象的过程。类加载机制是Java语言实现跨平台的重要特性之一
类加载机制原理如下：
1.加载：将类的字节码文件加载到内存中。字节码可以来自本地文件系统、网络等。类加载器负责加载字节码文件
2.验证：验证字节码文件的格式、语义等是否符合Java虚拟机规范。确保字节码文件的安全性和正确性
3.准备：为类的静态变量分配内存，并设置默认初始值。静态变量存储在方法区中
4.解析：将符号引用转换为直接引用。符号引用是一种字面量形式的引用，直接引用是指向对象、方法、字段的指针或偏移量
5.初始化：执行类的初始化代码，包括静态变量赋值和静态代码块的执行等。初始化阶段是类加载的最后一步，只有在该阶段完成后，类才能被正常使用
6.使用：类加载完成后，可以通过创建对象、调用方法等方式使用类
7.卸载：当类不再被使用时，会被卸载并从内存中释放
类加载机制的核心是类加载器，它负责加载类并生成对应的Class对象。Java虚拟机提供了三种类加载器：Bootstrap ClassLoader、Extension ClassLoader和Application ClassLoader。每个类加载器都有自己的加载范围和加载顺序
20.什么是类加载器|类加载器有哪些
类加载器是Java虚拟机（JVM）的一部分，负责将类的字节码文件加载到内存中，并生成对应的Class对象。类加载器是实现Java类加载机制的重要组成部分
Java中的类加载器分为以下几种：
1.Bootstrap ClassLoader（启动类加载器）：是JVM的一部分，负责加载Java核心类库，如java.lang包中的类。它是由C++实现的，不是Java类
2.Extension ClassLoader（扩展类加载器）：负责加载Java的扩展类库，位于JRE的lib/ext目录下的jar包。它是由Java实现的，是ClassLoader的子类。
3.Application ClassLoader（应用程序类加载器）：也称为系统类加载器，负责加载应用程序的类。它是ClassLoader的子类，是Java程序中默认的类加载器
除了这三种常见的类加载器，还可以通过自定义类加载器来实现特定的加载需求
类加载器的加载范围和加载顺序如下：
1.Bootstrap ClassLoader：加载JVM核心类库，无法被Java程序直接引用
2.Extension ClassLoader：加载JRE的扩展类库
3.Application ClassLoader：加载应用程序的类，包括自定义类和第三方库
类加载器的设计模式主要是使用了"责任链模式"。每个类加载器都有一个父加载器，当一个类需要被加载时，先由当前类加载器尝试加载，如果加载失败，则委托给父加载器进行加载，直到Bootstrap ClassLoader。这样形成了一个层级结构的类加载器链，每个加载器都有机会加载类。这种责任链模式的设计使得类加载器可以按照一定的顺序进行加载，提高了灵活性和可扩展性
21.类装载过程
Java类装载过程是指将类的字节码文件加载到内存中，并生成对应的Class对象的过程。类装载过程主要包括以下三个步骤：
1.加载：类的字节码文件被加载到内存中，并在堆中生成一个Class对象，用于描述这个类的结构信息。在加载阶段，JVM会根据类的全限定名（包括包名和类名）查找类的字节码文件，如果找到了就将其加载到内存中
2.链接：链接分为三个阶段：
1）验证：验证字节码文件的正确性，包括语法、类型、引用等方面的验证，以保证字节码文件的安全性和正确性
2）准备：为类变量（即静态变量）分配内存并设置初始值，包括基本类型的默认值和引用类型的null值
3）解析：将类中的符号引用（如类、方法、字段等）解析为直接引用（即内存地址），以便于执行时的调用和访问
3.初始化：执行类的初始化代码，包括静态变量的赋值和静态代码块的执行等。在初始化阶段，JVM会保证类的初始化是线程安全的，即同一时间只有一个线程可以对类进行初始化
22.什么是双亲委派模型|工作流程|好处
双亲委派模型是Java类加载机制中的一种设计模式，用于保证类的加载过程的安全和一致性。它的工作流程如下：
1.当一个类需要被加载时，首先会委托给最顶层的类加载器------启动类加载器（Bootstrap ClassLoader）进行加载
2.如果启动类加载器无法加载该类（即在它的搜索范围内找不到该类），则会将加载请求委托给扩展类加载器（Extension ClassLoader）进行加载
3.如果扩展类加载器也无法加载该类，则会将加载请求委托给应用程序类加载器（Application ClassLoader）进行加载
4.如果应用程序类加载器仍然无法加载该类，则会抛出ClassNotFoundException异常
5.如果应用程序类加载器成功加载了该类，则会将加载请求委托给父类加载器进行加载，直到最顶层的启动类加载器
6.如果父类加载器能够成功加载该类，则将加载的类返回给子类加载器，完成类加载过程
双亲委派模型的好处有以下几点：
1.避免类的重复加载：通过委派给父类加载器，可以避免同一个类被多次加载，保证类的唯一性和一致性
2.安全性：由于双亲委派模型会先尝试由父类加载器加载类，这样可以防止恶意类的加载，保证核心类库的安全性
3.避免类的冲突：通过委派给父类加载器，可以避免不同类加载器加载同一个类的冲突，保证类的隔离性
总之，双亲委派模型通过层层委托和优先级的方式，保证了类的加载过程的安全性、一致性和可靠性
23.JVM调优工具
1.VisualVM：VisualVM是一个强大的Java虚拟机监视和性能分析工具，可以监测应用程序的内存使用、线程状态、垃圾回收等，并提供了丰富的图形化界面和插件支持
2.JConsole：JConsole是Java自带的监控和管理工具，可以监测Java应用程序的内存、线程、垃圾回收等信息，并提供了图形化界面和MBean支持
3.Java Mission Control（JMC）：Java Mission Control是Oracle提供的一套高级性能监控和分析工具，可以在生产环境中对Java应用程序进行实时监控和分析，提供了丰富的数据收集和分析功能
4.Java Flight Recorder（JFR）：Java Flight Recorder是Java Mission Control的一部分，它可以在应用程序运行过程中收集各种性能数据，并生成详细的报告和分析结果
5.JVisualVM：JVisualVM是一个Java虚拟机监视和性能分析工具，提供了实时的内存和CPU使用情况、线程状态、垃圾回收等信息，可以生成线程和堆转储快照，进行性能分析和故障排查
24.GC调优思路
1.监控和分析GC日志：首先，需要开启GC日志，并收集应用程序的GC日志信息。通过分析GC日志，可以了解GC的频率、停顿时间、内存占用等情况，以及各个内存区域的使用情况
2.选择合适的垃圾回收器：根据应用程序的特点和需求，选择合适的垃圾回收器。不同的垃圾回收器有不同的特点和适用场景，例如，CMS回收器适用于低延迟场景，G1回收器适用于大内存和高吞吐量场景
3.调整堆大小：根据应用程序的内存需求和垃圾回收的情况，适当调整堆大小。如果堆过小，可能会导致频繁的垃圾回收和内存不足；如果堆过大，可能会导致垃圾回收的停顿时间过长
4.设置合理的GC参数：根据应用程序的特点和需求，设置合理的GC参数。例如，设置新生代和老年代的比例、设置GC的停顿时间目标、设置堆的分代大小等
5.优化对象的创建和销毁：减少对象的创建和销毁可以降低垃圾回收的压力。可以使用对象池、缓存重复使用的对象，避免频繁创建和销毁对象
6.优化内存使用：减少内存占用可以延缓垃圾回收的发生。可以通过优化数据结构、减少不必要的缓存、及时释放不再使用的资源等方式来减少内存占用
7.进行性能测试和评估：在进行GC调优后，进行性能测试和评估，观察GC的效果和应用程序的性能变化。根据测试结果，可以进一步优化和调整GC配置
25.常用JVM调优参数
1.-Xms: 设置堆的初始大小
2.-Xmx: 设置堆的最大大小
3.-Xmn: 设置新生代的大小
4.-XX:+PrintGC: 打印GC日志
26.什么工具监控JVM
1.JConsole：JDK自带的Java监控工具，可以监控JVM的内存、线程、类等信息，也可以进行JMX操作
2.VisualVM：JDK自带的可视化监控工具，可以监控JVM的内存、垃圾回收、线程、类等信息，也可以进行JMX操作，还支持插件扩展
27.JVM优化的目的是什么
JVM优化的目的是提高Java应用程序的性能和效率，以更好地满足用户的需求。具体来说，JVM优化的目标包括：
1.提高执行速度：通过优化JVM的即时编译器（JIT Compiler）和垃圾回收器等组件，可以加快Java应用程序的执行速度，提高其响应性和吞吐量
2.减少内存占用：通过优化垃圾回收器和内存管理策略，可以减少Java应用程序对内存的占用，提高内存利用率，降低系统的内存开销
3.降低资源消耗：通过合理配置JVM的参数和调优应用程序的代码，可以降低CPU和IO等资源的消耗，提高系统的效率和可扩展性
4.提高并发性能：通过优化线程和锁的使用，减少线程竞争和锁争用，可以提高Java应用程序在多线程环境下的并发性能
28.堆栈如何调优
1.堆调优：
调整堆的大小：可以通过-Xms和-Xmx参数来指定堆的初始大小和最大大小。合理设置堆的大小可以避免频繁的垃圾回收和内存溢出的问题
选择合适的垃圾回收器：不同的垃圾回收器有不同的特点和适用场景。根据应用程序的需求和硬件环境，选择合适的垃圾回收器可以提高垃圾回收的效率和性能
调整垃圾回收器的参数：可以通过调整垃圾回收器的参数，如年轻代和老年代的比例、垃圾回收的频率等，来优化垃圾回收的效果
避免过度创建对象：频繁创建和销毁对象会增加垃圾回收的负担。可以通过对象池、复用对象等方式来减少对象的创建和销毁，从而减轻垃圾回收的压力
2.栈调优：
合理设置栈的大小：可以通过-Xss参数来指定线程栈的大小。栈的大小决定了线程能够调用的方法的深度，过小的栈容易导致栈溢出，过大的栈会占用过多的内存
避免递归调用：递归调用会导致栈的深度增加，容易引发栈溢出的问题。可以尝试使用迭代或循环替代递归，以减少栈的深度
减少局部变量的使用：方法中的局部变量会存储在栈中，过多的局部变量会增加栈的使用量。可以尽量减少方法中的局部变量的数量和大小，以减少栈的压力
29.堆栈的区别
在Java中，堆和栈是两种不同的内存区域，用于存储不同类型的数据
1.存储内容：堆存储对象和数组，栈存储基本数据类型和对象的引用
2.管理方式：堆由Java虚拟机自动管理，程序员无法直接控制；栈由程序自动管理，程序员可以直接控制栈的大小和生命周期
3.空间分配：堆的大小可以通过启动JVM时设置的-Xms和-Xmx参数来调整；栈的大小由程序员在编写代码时设置。
4.访问方式：堆的访问速度相对较慢，因为需要通过引用来访问对象；栈的访问速度相对较快，因为数据存储在连续的内存空间中，可以直接访问
用，提高内存利用率，降低系统的内存开销
3.降低资源消耗：通过合理配置JVM的参数和调优应用程序的代码，可以降低CPU和IO等资源的消耗，提高系统的效率和可扩展性
4.提高并发性能：通过优化线程和锁的使用，减少线程竞争和锁争用，可以提高Java应用程序在多线程环境下的并发性能