GC垃圾回收面试看这篇就够了

桃扇骨 2022-02-01 06:57 257阅读 0赞

### GC ###

#### 你知道哪些垃圾回收算法? ####

垃圾回收从理论上非常容易理解,具体的方法有以下几种:

1.  标记-清除
2.  标记-复制
3.  标记-整理
4.  分代回收

#### 如何判断一个对象是否应该被回收 ####

这就是所谓的对象存活性判断，常用的方法有两种：1.引用计数法; 2.对象可达性分析。由  
于引用计数法存在互相引用导致无法进行 GC 的问题，所以目前 JVM  
虚拟机多使用对象可达 性分析算法。

#### 简单的解释一下垃圾回收 ####

Java 垃圾回收机制最基本的做法是分代回收。内存中的区域被划分成不同的世代，对象根  
据其存活的时间被保存在对应世代的区域中。一般的实现是划分成 3  
个世代：年轻、年老和  
永久。内存的分配是发生在年轻世代中的。当一个对象存活时间足够长的时候，它就会被复  
制到年老世代中。对于不同的世代可以使用不同的垃圾回收算法。进行世代划分的出发点是  
对应用中对象存活时间进行研究之后得出的统计规律。一般来说，一个应用中的大部分对象  
的存活时间都很短。比如局部变量的存活时间就只在方法的执行过程中。基于这一点，对于  
年轻世代的垃圾回收算法就可以很有针对性。

#### java 当中的四种引用 ####

强引用，软引用，弱引用，虚引用。不同的引用类型主要体现在 GC 上:

强引用：如果一个对象具有强引用，它就不会被垃圾回收器回收。即使当前内存空  
间不足，JVM 也不会回收它，而是抛出 OutOfMemoryError 错误，使程序异常终止。  
如果想中断强引用和某个对象之间的关联，可以显式地将引用赋值为 null，这样一  
来的话，JVM 在合适的时间就会回收该对象。

软引用：在使用软引用时，如果内存的空间足够，软引用就能继续被使用，而不会  
被垃圾回收器回收，只有在内存不足时，软引用才会被垃圾回收器回收。

虚引用：顾名思义，就是形同虚设，如果一个对象仅持有虚引用，那么它相当于没  
有引用，在任何时候都可能被垃圾回收器回收。

#### 调用 System.gc()会发生什么? ####

通知 GC 开始工作，但是 GC 真正开始的时间不确定。

#### GC是什么，为什么要使用它？【阿斯拓】 ####

**GC是垃圾收集的意思（GabageCollection）**,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能\*\*可以自动监测对象是否超过作用域，从而达到自动回收内存的目的，\*\*Java语言没有提供释放已分配内存的显示操作方法。

#### 说一下垃圾回收的原理，可以直接从内存中回收吗? ####

**Java语言中一个显著的特点就是引入了垃圾回收机制**，使c++程序员最头疼的内存管理的问题迎刃而解，它**使得Java程序员在编写程序的时候不再需要考虑内存管理。垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低级别的线程运行**，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清除和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收,因为Java语言规范并不保证GC一定会执行。回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收。

#### 垃圾回收机制概述 ####

Java语言中一个显著的特点就是引入了垃圾回收机制，使c++程序员最头疼的内存管理的问题迎刃而解，它使得Java程序员在编写程序的时候不再需要考虑内存管理。由于有个垃圾回收机制，Java中的对象不再有“作用域”的概念，只有对象的引用才有“作用域”。垃圾回收可以有效的防止内存泄露，有效的使用空闲的内存。

ps:内存泄露是指该内存空间使用完毕之后未回收，在不涉及复杂数据结构的一般情况下，Java  
的内存泄露表现为一个内存对象的生命周期超出了程序需要它的时间长度，我们有时也将其称为“对象游离”。

#### 垃圾回收简要过程 ####

这里必须点出一个很重要的误区：不可达的对象并不会马上就会被直接回收，而是至少要经过两次标记的过程。\*\* \*\*  
\*\*        **第一次被标记过的对象，会检查该对象是否重写了finalize()方法。如果重写了该方法，则将其放入一个F-Query队列中，否则，直接将对象加入“即将回收”集合。在第二次标记之前，F-Query队列中的所有对象会逐个执行finalize()方法，但是不保证该队列中所有对象的finalize()方法都能被执行，这是因为JVM创建一个低优先级的线程去运行此队列中的方法，很可能在没有遍历完之前，就已经被剥夺了运行的权利。那么运行finalize()方法的意义何在呢？这是对象避免自己被清理的最后手段：如果在执行finalize()方法的过程中，使得此对象重新与GC  
Roots引用链相连，则会在第二次标记过程中将此对象从F-Query队列中清除，避免在这次回收中被清除，恢复成了一个“正常”的对象。但显然这种好事不能无限的发生，对于曾经执行过一次finalize()的对象来说，之后如果再被标记，则不会再执行finalize()方法，只能等待被清除的命运。** \*\*  
\*\*        \*\*之后，GC将对F-Queue中的对象进行第二次小规模的标记，将队列中重新与GC  
Roots引用链恢复连接的对象清除出“即将回收”集合。所有此集合中的内容将被回收。

#### 手动GC回收 ####

<table> 
 <thead> 
  <tr> 
   <th><strong>public class</strong> JVMDemo05 { <strong>public static void</strong> main(String[] args) { JVMDemo05 <em>jvmDemo05</em> = <strong>new</strong> JVMDemo05(); //jvmDemo05 = null; System.<em>gc</em>(); } <strong>protected void</strong> finalize() <strong>throws</strong> Throwable { System.<em>out</em>.println(“gc在回收对象…”); } }</th> 
  </tr> 
 </thead> 
 <tbody></tbody> 
</table>

#### finalize作用 ####

**Java技术使用finalize()方法在垃圾收集器将对象从内存中清除出去前，做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在Object类中定义的，因此所有的类都继承了它。子类覆盖finalize()方法以整理系统资源或者执行其他清理工作。finalize()方法是在垃圾收集器删除对象之前对这个对象调用的。**

#### 垃圾回收机制算法 ####

##### 引用计数法 #####

###### 概述 ######

**给对象中添加一个引用计数器，每当有一个地方引用它时，计数器值就加1；当引用失效时，计数器值就减1；任何时刻计数器都为0的对象就是不再被使用的，垃圾收集器将回收该对象使用的内存。**

###### 优缺点 ######

**优点：**

**引用计数收集器可以很快的执行，交织在程序运行中。对程序需要不被长时间打断的实时环境比较有利。**

**缺点：**

**无法检测出循环引用。如父对象有一个对子对象的引用，子对象反过来引用父对象。这样，他们的引用计数永远不可能为0.而且每次加减非常浪费内存。**

##### 标记清除算法 #####

**标记-清除（Mark-Sweep）算法顾名思义，主要就是两个动作，一个是标记，另一个就是清除。**

**标记就是根据特定的算法（如：引用计数算法，可达性分析算法等）标出内存中哪些对象可以回收，哪些对象还要继续用。**

**标记指示回收，那就直接收掉；标记指示对象还能用，那就原地不动留下。**

![这里写图片描述][Image 1]

**缺点**

1.  **标记与清除效率低;**
2.  **清除之后内存会产生大量碎片；**

**所以碎片这个问题还得处理，怎么处理，看标记-整理算法。**

##### 复制算法 #####

**S0和s1将可用内存按容量分成大小相等的两块，每次只使用其中一块，当这块内存使用完了，就将还存活的对象复制到另一块内存上去，然后把使用过的内存空间一次清理掉。这样使得每次都是对其中一块内存进行回收，内存分配时不用考虑内存碎片等复杂情况，只需要移动堆顶指针，按顺序分配内存即可，实现简单，运行高效。**

**复制算法的缺点显而易见，可使用的内存降为原来一半。**

**复制算法用于在新生代垃圾回收**

##### 标记-压缩算法 #####

标记压缩法在标记清除基础之上做了优化，把存活的对象压缩到内存一端,而后进行垃圾清理。(java中老年代使用的就是标记压缩法)

##### 分代收集算法 #####

根据内存中对象的存活周期不同，将内存划分为几块，java的虚拟机中一般把内存划分为新生代和年老代，当新创建对象时一般在新生代中分配内存空间，当新生代垃圾收集器回收几次之后仍然存活的对象会被移动到年老代内存中，当大对象在新生代中无法找到足够的连续内存时也直接在年老代中创建。

对于新生代和老年代来说,新生代回收频率很高,但是每次回收耗时很短,而老年代回收频率较低,但是耗时会相对较长,所以应该尽量减少老年代的GC.

##### 为什么老年代使用标记压缩、新生代使用复制算法。 #####

##### 垃圾回收时的停顿现象 #####

垃圾回收的任务是识别和回收垃圾对象进行内存清理，为了让垃圾回收器可以更高效的执行，大部分情况下，会要求系统进如一个停顿的状态。停顿的目的是为了终止所有的应用线程，只有这样的系统才不会有新垃圾的产生。同时停顿保证了系统状态在某一个瞬间的一致性，也有利于更好的标记垃圾对象。因此在垃圾回收时，都会产生应用程序的停顿。

#### 垃圾收集器 ####

##### 什么是Java垃圾回收器 #####

Java垃圾回收器是Java虚拟机(JVM)的三个重要模块(另外两个是解释器和多线程机制)之一，为应用程序提供内存的**自动分配(Memory  
Allocation)、自动回收(Garbage  
Collect)功能，这两个操作都发生在Java堆上(一段内存快)。某一个时点，一个对象如果有一个以上的引用(Rreference)指向它，那么该对象就为活着的(Live)，否则死亡(Dead)，视为垃圾，可被垃圾回收器回收再利用。垃圾回收操作需要消耗CPU、线程、时间等资源，所以容易理解的是垃圾回收操作不是实时的发生**(对象死亡马上释放)，当内存消耗完或者是达到某一个指标(Threshold,使用内存占总内存的比列，比如0.75)时，触发垃圾回收操作。有一个对象死亡的例外，java.lang.Thread类型的对象即使没有引用，只要线程还在运行，就不会被回收。

##### 串行回收器(Serial Collector) #####

单线程执行回收操作，回收期间暂停所有应用线程的执行，client模式下的默认回收器，通过-XX:+UseSerialGC命令行可选项强制指定。**参数可以设置使用新生代串行和老年代串行回收器**

年轻代的回收算法(Minor Collection)  
把Eden区的存活对象移到To区，To区装不下直接移到年老代，把From区的移到To区，To区装不下直接移到年老代，From区里面年龄很大的升级到年老代。  
回收结束之后，Eden和From区都为空，此时把From和To的功能互换，From变To，To变From，每一轮回收之前To都是空的。设计的选型为复制。

年老代的回收算法(Full Collection)  
年老代的回收分为三个步骤，标记(Mark)、清除(Sweep)、合并(Compact)。标记阶段把所有存活的对象标记出来，清除阶段释放所有死亡的对象，合并阶段  
把所有活着的对象合并到年老代的前部分，把空闲的片段都留到后面。设计的选型为合并，减少内存的碎片。

##### 并行回收 #####

###### 并行回收器(ParNew回收器) ######

并行回收器在串行回收器基础上做了改进，他可以使用多个线程同时进行垃  
圾回收，对于计算能力强的计算机而言，可以有效的缩短垃圾回收所需的尖  
际时间。  
**ParNew回收器是一个工作在新生代的垃圾收集器**，他只是简单的将串行回收  
器多线程快他的回收策略和算法和串行回收器一样。  
使用**XX:+UseParNewGC 新生代ParNew回收器**，老年代则使用市行回收器  
ParNew回收器工作时的线程数量可以使用**XX:ParaleiGCThreads**参数指  
定，一般最好和计算机的CPU相当，避免过多的栽程影响性能。

###### 并行回收集器(ParallelGC) ######

老年代ParallelOldGC回收器也是一种多线程的回收器，和新生代的  
ParallelGC回收器一样，也是一种关往吞吐量的回收器，他使用了标记压缩  
算法进行实现。  
\-XX:+UseParallelOldGC 进行设置  
\-XX:+ParallelCThread也可以设置垃圾收集时的线程教量。

##### 串行并行回收区别 #####

串行单核，并行多核，后者效率高。

##### 并CMS(并发GC)收集器 #####

CMS(Concurrent Mark  
Sweep)收集器是一种以获取最短回收停顿时间为目标的收集器。CMS收集器是基于“标记-清除”算法实现的，整个收集过程大致分为4个步骤：

①.初始标记(CMS initial mark)

②.并发标记(CMS concurrenr mark)

③.重新标记(CMS remark)

④.并发清除(CMS concurrent sweep)

其中初始标记、重新标记这两个步骤任然需要停顿其他用户线程。初始标记仅仅只是标记出GC  
ROOTS能直接关联到的对象，速度很快，并发标记阶段是进行GC ROOTS  
根搜索算法阶段，会判定对象是否存活。而重新标记阶段则是为了修正并发标记期间，因用户程序继续运行而导致标记产生变动的那一部分对象的标记记录，这个阶段的停顿时间会被初始标记阶段稍长，但比并发标记阶段要短。

由于整个过程中耗时最长的并发标记和并发清除过程中，收集器线程都可以与用户线程一起工作，所以整体来说，CMS收集器的内存回收过程是与用户线程一起并发执行的。

CMS收集器的优点：并发收集、低停顿，但是CMS还远远达不到完美，器主要有三个显著缺点：

CMS收集器对CPU资源非常敏感。在并发阶段，虽然不会导致用户线程停顿，但是会占用CPU资源而导致引用程序变慢，总吞吐量下降。CMS默认启动的回收线程数是：(CPU数量+3)  
/ 4。

CMS收集器无法处理浮动垃圾，可能出现“Concurrent Mode  
Failure“，失败后而导致另一次Full  
 GC的产生。由于CMS并发清理阶段用户线程还在运行，伴随程序的运行自热会有新的垃圾不断产生，这一部分垃圾出现在标记过程之后，CMS无法在本次收集中处理它们，只好留待下一次GC时将其清理掉。这一部分垃圾称为“浮动垃圾”。也是由于在垃圾收集阶段用户线程还需要运行，  
即需要预留足够的内存空间给用户线程使用，因此CMS收集器不能像其他收集器那样等到老年代几乎完全被填满了再进行收集，需要预留一部分内存空间提供并发收集时的程序运作使用。在默认设置下，CMS收集器在老年代使用了68%的空间时就会被激活，也可以通过参数-XX:CMSInitiatingOccupancyFraction的值来提供触发百分比，以降低内存回收次数提高性能。要是CMS运行期间预留的内存无法满足程序其他线程需要，就会出现“Concurrent  
Mode Failure”失败，这时候虚拟机将启动后备预案：临时启用Serial  
Old收集器来重新进行老年代的垃圾收集，这样停顿时间就很长了。所以说参数-XX:CMSInitiatingOccupancyFraction设置的过高将会很容易导致“Concurrent  
Mode Failure”失败，性能反而降低。

最后一个缺点，CMS是基于“标记-清除”算法实现的收集器，使用“标记-清除”算法收集后，会产生大量碎片。空间碎片太多时，将会给对象分配带来很多麻烦，比如说大对象，内存空间找不到连续的空间来分配不得不提前触发一次Full  
 GC。为了解决这个问题，CMS收集器提供了一个-XX:UseCMSCompactAtFullCollection开关参数，用于在Full  
 GC之后增加一个碎片整理过程，还可通过-XX:CMSFullGCBeforeCompaction参数设置执行多少次不压缩的Full  
 GC之后，跟着来一次碎片整理过程。

##### G1回收器 #####

G1回收器(Garbage-First)实在\]dk1.7中提出的垃圾回收器，从长期目标来看是为了取  
代CMS回收器，G1回收器拥有独特的垃圾回收策略，G1属于分代垃圾回收器，区分  
新生代和老年代，依然有eden和from/to区,它并不要求整个eden区或者新生代、老  
年代的空间都连续，它使用了分区算法。  
并行性: G1回收期间可多线程同时工作。  
井发性G1拥有与应用程序交替执行能力，部分工作可与应用程序同时执行，在整个  
GC期间不会完全阻塞应用程序。  
分代GC:G1依然是一个分代的收集器，但是它是非两新生代和老年代一杯政的杂尊。  
空间基理，G1在国收过程中，不会微CMS那样在若千tacAy 要进行碎片整理。  
G1  
来用了有效复制对象的方式，减少空间碎片。  
利得程，用于分区的原因，G可以贝造取都分区城进行回收，帽小了国收的格想，  
提升了性能。  
[使用.XXX][.XXX]:+UseG1GC 应用G1收集器，  
Mills指定最大停顿时间  
使用-XX:MaxGCPausel  
设置并行回收的线程数量  
使用-XX:ParallelGCThreads

#### 调优总结 ####

**初始堆值和最大堆内存内存越大，吞吐量就越高。**

**最好使用并行收集器,因为并行手机器速度比串行吞吐量高，速度快。**

**设置堆内存新生代的比例和老年代的比例最好为1:2或者1:3。**

**减少GC对老年代的回收。**

##### JVM工作原理？ #####

运行jvm字符码的工作是由解释器来完成的。解释执行过程分三步进行：

代码的装入、代码的校验、和代码的执行。

装入代码的工作由“类装载器classloader”完成。类装载器负责装入运行一个程序需要的所有代码，这也包括程序代码中的类所继承的类和被调用的类。当类装载器装入一个类时，该类被放在自己的名字空间中。除了通过符号引用自己名字空间以外的类，类之间没有其他办法可以影响其他类。在本台计算机的所有类都在同一地址空间中，而所有从外部引进的类，都有一个自己独立的名字空间。这使得本地类通过共享相同的名字空间获得较高的运行效率，同时又保证它们与从外部引进的类不会相互影响。当装入了运行程序需要的所有类后，解释器便可确定整个可执行程序的内存布局。解释器为符号引用与特定的地址空间建立对应关系及查询表。通过在这一阶段确定代码的内布局，java很好地解决了由超类改变而使子类

崩溃的问题，同时也防止了代码的非法访问。随后，被装入的代码由字节码校验器进行检查。校验器可以发现操作数栈益处、非法数据类型转化等多种错误。通过校验后，代码便开始执行了。

Java字节码的执行有两种方式：

1）即时编译方式：解释器先将字节编译成机器码，然后再执行该机器码。

2）解释执行方式：解释器通过每次解释并执行一小段代码来完成java字节。

码程序的所有操作。

##### JVM加载class文件原理？ #####

所谓装载就是寻找一个类或是一个接口的二进制形式并用该二进制形式来构造代表这个类或是这个接口的class对象的过程.

在Java中，类装载器把一个类装入Java虚拟机中，要经过三个步骤来完成：装载、链接和初始化,其中链接又可以分成校验、准备、解析

装载：查找和导入类或接口的二进制数据；

链接：执行下面的校验、准备和解析步骤，其中解析步骤是可以选择的；

校验：检查导入类或接口的二进制数据的正确性；

准备：给类的静态变量分配并初始化存储空间；

解析：将符号引用转成直接引用；

初始化：激活类的静态变量的初始化Java代码和静态Java代码块

JVM中类的装载是由ClassLoader和它的子类来实现的,JavaClassLoader是一个重要的Java运行时系统组件。它负责在运行时查找和装入类文件的类

一个Java应用程序使用两种类型的类装载器：根装载器(bootstrap)和用户定义的装载器(user-defined)。

根装载器以某种默认的方式将类装入，包括那些JavaAPI的类。在运行期间一个Java程序能安装用户自己定义的类装载器。根装载器是虚拟机固有的一部分，而用户定义的类装载器则不是，它是用Java语言写的，被编译成class文件之后然后再被装入到虚拟机，并像其它的任何对象一样可以被实例化。Java类装载器的体系结构如下所示：

Bootstrap(根装载器)

Extension(扩展装载器)

System

UserDefine1

/\\

UserDefine2UserDefine3

UserDefine4

Java的类装载模型是一种代理(delegation)模型。当JVM要求类装载器CL(ClassLoader)装载一个类时,CL首先将这个类装载请求转发给他的父装载器。只有当父装载器没有装载并无法装载这个类时,CL才获得装载这个类的机会。这样,所有类装载器的代理关系构成了一种树状的关系。树的根是类的根装载器(bootstrapClassLoader),在JVM中它以"null"表示。除根装载器以外的类装载器有且仅有一个父装载器。在创建一个装载器时,如果没有显式地给出父装载器,那么JVM将默认系统装载器为其父装载器

下面针对各种类装载器分别进行详细的说明：

根(Bootstrap)装载器:该装载器没有父装载器，它是JVM实现的一部分，从sun.boot.class.path装载运行时库的核心代码。

扩展(Extension)装载器:继承的父装载器为根装载器，不像根装载器可能与运行时的操作系统有关，这个类装载器是用纯Java代码实现的，它从java.ext.dirs(扩展目录)中装载代码。

系统(SystemorApplication)装载器:装载器为扩展装载器，我们都知道在安装JDK的时候要设置环境变量(CLASSPATH)，这个类装载器就是从java.class.path(CLASSPATH环境变量)中装载代码的，它也是用纯Java代码实现的，同时还是用户自定义类装载器的缺省父装载器。

小应用程序(Applet)装载器:装载器为系统装载器，它从用户指定的网络上的特定目录装载小应用程序代码。

##### 说说Java中的内存分配? #####

Java把内存分成两种，一种叫做栈内存，一种叫做堆内存

在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配。当在一段代码块中定义一个变量时，java就在栈中为这个变量分配内存空间，当超过变量的作用域后，java会自动释放掉为该变量分配的内存空间，该内存空间可以立刻被另作它用。

堆内存用于存放由new创建的对象和数组。在堆中分配的内存，由java虚拟机自动垃圾回收器来管理。在堆中产生了一个数组或者对象后，还可以在栈中定义一个特殊的变量，这个变量的取值等于数组或者对象在堆内存中的首地址，在栈中的这个特殊的变量就变成了数组或者对象的引用变量，以后就可以在程序中使用栈内存中的引用变量来访问堆中的数组或者对象，引用变量相当于为数组或者对象起的一个别名，或者代号。

引用变量是普通变量，定义时在栈中分配内存，引用变量在程序运行到作用域外释放。而数组＆对象本身在堆中分配，即使程序运行到使用new产生数组和对象的语句所在地代码块之外，数组和对象本身占用的堆内存也不会被释放，数组和对象在没有引用变量指向它的时候，才变成垃圾，不能再被使用，但是仍然占着内存，在随后的一个不确定的时间被垃圾回收器释放掉。这个也是java比较占内存的主要原因。但是在写程序的时候，可以人为的控制。

##### GC经常回收好不好 #####

不好，GC在回收线程的时候，其他线程全部等待。时间很短，速度快，看不到效果。

##### 为什么老年代使用标记压缩、新生代使用复制算法。 #####

##### 说下你熟悉那些jvm参数调优 #####

\-XX:+UseSerialGC 设置使用新生代串行和老年代串行回收器

XX:+UseParNewGC新生代并行回收器

##### 串行回收和并行回收的区别 #####

串行是单线程回收，效率较慢

并行回收是多线程回收，效率快。

cms也是并行。

##### ClassLoader如何加载class。 #####

jvm里有多个类加载，每个类加载可以负责加载特定位置的类，例如，bootstrap类加载负责加载jre/lib/rt.jar中的类，我们平时用的jdk中的类都位于rt.jar中。extclassloader负责加载jar/lib/ext/\*.jar中的类，appclassloader负责classpath指定的目录或jar中的类。除了bootstrap之外，其他的类加载器本身也都是java类，它们的父类是ClassLoader。

[Image 1]: 
[.XXX]: http://xn--2rqz13g.XXX