深入理解JVM一一一自动内存管理机制一一一Java垃圾回收机制(GC)

最新推荐文章于 2024-07-29 10:33:25 发布

西门吹菊

最新推荐文章于 2024-07-29 10:33:25 发布

阅读量491

点赞数 2

分类专栏： JVM

本文链接：https://blog.csdn.net/wang7241/article/details/91815032

版权

JVM 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

声明：本文内容主要参考引用自：

https://www.cnblogs.com/dolphin0520/p/3783345.html

https://blog.csdn.net/zl1zl2zl3/article/details/90904088

https://www.jianshu.com/p/8f5fa8288d9b

https://blog.csdn.net/luzhensmart/article/details/81431212

https://www.cnblogs.com/1024Community/p/honery.html

https://blog.csdn.net/cool_summer_moon/article/details/80400898

一、概念：什么是垃圾回收?

通俗地说：垃圾收集(Garbage Collection,GC)又俗称为垃圾回收，是一种在堆内存中找出哪些对象在被使用，还有哪些对象没被使用，并且将后者删除掉的机制。所谓使用中的对象，指的是被引用的对象。所以回收的是目标是对象。

二、引申：对象和对象引用

为便于说明，我们先定义一个简单的类：

   class Vehicle {
       int passengers;     
                 }

有了这个模板，就可以用它来创建对象：

Vehicle veh = new Vehicle();

通常把这条语句的动作称之为创建一个对象，其实，它包含了四个动作。
1）右边的“new Vehicle”，是以Vehicle类为模板，在堆空间里创建一个Vehicle类对象（也简称为Vehicle对象）。

2）末尾的()意味着，在对象创建后，立即调用Vehicle类的构造函数，对刚生成的对象进行初始化。构造函数是肯定有的。如果你没写，Java会给你补上一个默认的构造函数。

3）左边的“Vehicle veh ”创建了一个Vehicle类引用变量。所谓Vehicle类引用，就是以后可以用来指向Vehicle对象的对象引用。

4）“=” 操作符使对象引用指向刚创建的那个Vehicle对象。

综上所述，可以简单的记为，在初始化时，“=” 语句左边的是引用，右边new出来的是对象。

详解可参考：Java对象引用及对象赋值

三、如何确定某个对象是“垃圾”？

知道了垃圾回收器是个什么概念之后，就想着它是如何工作的，但在此之前得先了解垃圾收集器是如何判断一个对象是可以被回收的，即结合概念理解如何判断一个对象真正没被使用。

1.引用计数法:

在java中是通过引用来和对象进行关联的，也就是说如果要操作对象，必须通过引用来进行。那么很显然一个简单的办法就是通过引用计数来判断一个对象是否可以被回收。不失一般性，如果一个对象没有任何引用与之关联，则说明该对象基本不太可能在其他地方被使用到，那么这个对象就成为可被回收的对象了。

这种方式的特点是实现简单，而且效率较高，但是它无法解决循环引用的问题，因此在Java中并没有采用这种方式（Python采用的是引用计数法）。看下面这段代码：

public class Main {
    public static void main(String[] args) {
        MyObject object1 = new MyObject();
        MyObject object2 = new MyObject();
         
        object1.object = object2;
        object2.object = object1;
         
        object1 = null;
        object2 = null;
    }
}
 
class MyObject{
    public Object object = null;
}

最后面两句将object1和object2赋值为null，也就是说object1和object2指向的对象已经不可能再被访问，但是由于它们互相引用对方，导致它们的引用计数都不为0，那么垃圾收集器就永远不会回收它们。

2.可达性分析法(Reachability Analysis):

为了解决这个问题，在Java中采取了可达性分析法。该方法的基本思想是通过一系列的“GC Roots”对象作为起点进行搜索，如果在“GC Roots”和一个对象之间没有可达路径，则称该对象是不可达的，不过要注意的是被判定为不可达的对象不一定就会成为可回收对象。

被判定为不可达的对象要成为可回收对象必须至少经历两次标记过程，如果在这两次标记过程中仍然没有逃脱成为可回收对象的可能性，则基本上就真的成为可回收对象了。

如上图所示，object1~object4对GC Root都是可达的，说明不可被回收，object5和object6对GC Root节点不可达，说明其可以被回收。
在Java中，可作为GC Root的对象包括以下几种：

虚拟机栈（栈帧中的本地变量表）中引用的对象(可以理解为:引用栈帧中的本地变量表的所有对象)
方法区中类静态属性引用的对象(可以理解为:引用方法区该静态属性的所有对象)
方法区中常量引用的对象(可以理解为:引用方法区中常量的所有对象)
本地方法栈中JNI（即一般说的Native方法）引用的对象(可以理解为:引用Native方法的所有对象)

最后为了便于实际理解，总结一下平常遇到的比较常见的将对象判定为可回收对象的情况。

1）显示地将某个引用赋值为null或者将已经指向某个对象的引用指向新的对象

Object obj = new Object();
obj = null;
Object obj1 = new Object();
Object obj2 = new Object();
obj1 = obj2;

2）局部引用所指向的对象

void fun() {
 
.....
    for(int i=0;i<10;i++) {
        Object obj = new Object();
        System.out.println(obj.getClass());
    }   
}

循环每执行完一次，生成的Object对象都会成为可回收的对象

3）只有弱引用与其关联的对象

WeakReference<String> wr = new WeakReference<String>(new String("world"));

详解可参考：可达性算法、Java引用详解

四、典型的垃圾收集算法

在确定了哪些垃圾可以被回收后，垃圾收集器要做的事情就是开始进行垃圾回收，但是这里面涉及到一个问题是：如何高效地进行垃圾回收。由于Java虚拟机规范并没有对如何实现垃圾收集器做出明确的规定，因此各个厂商的虚拟机可以采用不同的方式来实现垃圾收集器，所以在此只讨论几种常见的垃圾收集算法的核心思想。

1.Mark-Sweep（标记-清除）算法

这是最基础的垃圾回收算法，之所以说它是最基础的是因为它最容易实现，思想也是最简单的。标记-清除算法分为两个阶段：标记阶段和清除阶段。标记阶段的任务是标记出所有需要被回收的对象，清除阶段就是回收被标记的对象所占用的空间。具体过程如下图所示：

从图中可以很容易看出标记-清除算法实现起来比较容易，但是有一个比较严重的问题就是容易产生内存碎片，碎片太多可能会导致后续过程中需要为大对象分配空间时无法找到足够的空间而提前触发新的一次垃圾收集动作。

2.Copying（复制）算法

为了解决Mark-Sweep算法的缺陷，Copying算法就被提了出来。它将可用内存按容量划分为大小相等的两块，每次只使用其中的一块。当这一块的内存用完了，就将还存活着的对象复制到另外一块上面，然后再把已使用的内存空间一次清理掉，这样一来就不容易出现内存碎片的问题。具体过程如下图所示：

这种算法虽然实现简单，运行高效且不容易产生内存碎片，但是却对内存空间的使用做出了高昂的代价，因为能够使用的内存缩减到原来的一半。很显然，Copying算法的效率跟存活对象的数目多少有很大的关系，如果存活对象很多，那么Copying算法的效率将会大大降低。

3.Mark-Compact（标记-整理）算法

为了解决Copying算法的缺陷，充分利用内存空间，提出了Mark-Compact算法。该算法标记阶段和Mark-Sweep一样，但是在完成标记之后，它不是直接清理可回收对象，而是将存活对象都向一端移动，然后清理掉端边界以外的内存。具体过程如下图所示：

4.Generational Collection（分代收集）算法

分代收集算法是目前大部分JVM的垃圾收集器采用的算法。它的核心思想是根据对象存活的生命周期将内存划分为若干个不同的区域。一般情况下将堆区划分为老年代（Tenured Generation）和新生代（Young Generation），老年代的特点是每次垃圾收集时只有少量对象需要被回收，而新生代的特点是每次垃圾回收时都有大量的对象需要被回收，那么就可以根据不同代的特点采取最适合的收集算法。

　　目前大部分垃圾收集器对于新生代都采取Copying算法，因为新生代中每次垃圾回收都要回收大部分对象，也就是说需要复制的操作次数较少，但是实际中并不是按照1：1的比例来划分新生代的空间的，一般来说是将新生代划分为一块较大的Eden空间和两块较小的Survivor空间，每次使用Eden空间和其中的一块Survivor空间，当进行回收时，将Eden和Survivor中还存活的对象复制到另一块Survivor空间中，然后清理掉Eden和刚才使用过的Survivor空间。

　　而由于老年代的特点是每次回收都只回收少量对象，一般使用的是Mark-Compact算法。

　　注意，在堆区之外还有一个代就是永久代（Permanet Generation），它用来存储class类、常量、方法描述等。对永久代的回收主要回收两部分内容：废弃常量和无用的类。

分代垃圾收集过程详解可参考：图解 Java 垃圾回收机制

五、典型的垃圾收集器

垃圾收集算法是内存回收的理论基础，而垃圾收集器就是内存回收的具体实现。下面介绍一下HotSpot（JDK 7)虚拟机提供的几种垃圾收集器，用户可以根据自己的需求组合出各个年代使用的收集器。

1.串行收集器的实现：serial（用于新生代，采用复制算法）、serial old（用于年老代，采用标记/整理算法）。

2.并行收集器的实现：ParNew（用于新生代，采用复制算法）、Parallel Scavenge（用于新生代，采用复制算法）、Parallel old（用于年老代，采用标记/整理算法）。

3.并发收集器的实现：concurrent mark sweep[CMS]（用于年老代，采用标记/清除算法）。

4. Garbage First(G1)：用于新生代和老年代，新生代采用复制算法、老年代采用标记-整理。

垃圾收集器各自的特点可参考：深入理解JVM------垃圾收集器各自特点

下面我们来一起看下jdk垃圾回收的大家庭以及它们之间的相互组合关系：

针对上面简单说明下，上面三个是新生代收集器，下面三个是老年代收集器，两者之间的连线表示两者可以配合使用，中间的G1收集器两代皆可。

这里补充一个并行和并发区别的知识点：

并行（parallellism）：多个事件在同一时间点执行。

并发（concurrency）：多个事件在同一时间段执行。

详解可参考：深入理解JVM------垃圾收集器

六、何时触发GC

了解了GC的基本工作原理了,但它是何时工作的呢?

由于对象进行了分代处理，因此垃圾回收区域、时间也不一样。GC有两种类型：Scavenge GC和Full GC。

1. Scavenge GC

一般情况下，当新对象生成，并且在Eden申请空间失败时，就会触发Scavenge GC，对Eden区域进行GC，清除非存活对象，并且把尚且存活的对象移动到Survivor区。然后整理Survivor的两个区。这种方式的GC是对年轻代的Eden区进行，不会影响到老年代。因为大部分对象都是从Eden区开始的，同时Eden区不会分配的很大，所以Eden区的GC会频繁进行。因而，一般在这里需要使用速度快、效率高的算法，使Eden去能尽快空闲出来。