java垃圾回收机制

GC
Java面试
发布日期:   2020-03-27
文章字数:   2.6k
阅读时长:   10 分
阅读次数:  

一、判定对象是否为垃圾的算法

被判定为垃圾的标准

不再被引用的对象称为垃圾

1、引用计数算法

判断对象的引用数量

  • 通过判断对象的引用数量来决定对象是否可以被回收
  • 每个对象实例都有一个引用计数器,被引用则+1,完成引用则-1
  • 任何引用计数为0的对象实例可以被当作垃圾收集

优缺点：

  • 优点:执行效率高,程序执行受影响较小
  • 缺点:无法检测出循环引用的情况,导致内存泄露

2、可达性分析算法

通过判断对象的引用链是否可达来决定对象是否可以被回收

图片来源：https://blog.csdn.net/xiaohulunb/article/details/103837408

可以作为GC Root的对象

  • 虚拟机栈中引用的对象(栈帧中的本地变量表)
  • 方法区中的常量引用的对象
  • 方法区中的类静态属性引用的对象
  • 本地方法栈中JNI ( Native方法)的引用对象
  • 活跃线程的引用对象

二、谈谈你了解的垃圾回收算法

标记-清除算法(Mark and Sweep)

  • 标记:从根集合进行扫描,对存活的对象进行标记
  • 清除:对堆内存从头到尾进行线性遍历,回收不可达对象内存

复制算法(Copying)

  • 分为对象面和空闲面
  • 对象在对象面上创建
  • 存活的对象被从对象面复制到空闲面
  • 将对象面所有对象内存清除

适用于对象存活率低的场景，一般用在老年代中

  • 解决碎片化问题

  • 顺序分配内存，简单高效

  • 适用于对象存活率低的场景

标记-整理算法(Compacting)

  • 标记:从根集合进行扫描,对存活的对象进行标记
  • 清除:移动所有存活的对象,且按照内存地址次序依次排列,然后
    将末端内存地址以后的内存全部回收。

适用于对象存活率高的场景

图片来源：http://www.justdojava.com/2019/12/14/jvm-gc/

  • 避免内存的不连续性
  • 不用设置两块内存互换
  • 适用于存活率高的场景

分代收集算法(Generational Collector)

  • 垃圾回收算法的组合拳
  • 按照对象生命周期的不同划分区域以采用不同的垃圾回收算法

目的：提高JVM回收效率

jdk8以前：

永久代用于存放静态文件，如Java类、方法等。该区域回收与上述“方法区内存回收”一致。但是永久代是使用的堆内存，如果创建对象太多容易造成内存溢出OOM（OutOfMemory）。

jdk6、jdk7

jdk8以后：

jdk8以后便取消了永久代的说法，而是用元空间代替，所存内容没有变化，只是存储的地址有所改变，元空间使用的是主机内存，而不是堆内存，元空间的大小限制受主机内存限制，这样有效的避免了创建大量对象时发生内存溢出的情况。

jdk8以后

图片来源：http://blog.beifengtz.com/article/51

三、GC

GC的分类

  • Minor GC
  • Full GC

年轻代

尽可能快速地收集掉那些生命周期短的对象

  • Eden区

  • 两个Survivor区

图片来源：http://blog.beifengtz.com/article/51

对象如何晋升到老年代？

  • 经历一定Minor次数依然存活的对象
  • Survivor区中存放不下的对象
  • 新生成的大对象( -XX: + PretenuerSizeThreshold )

常用的调优参数

  • -XX:SurvivorRatio : Eden和Survivor的比值,默认8 : 1
  • -XX:NewRatio :老年代和年轻代内存大小的比例（通过JVM调优参数决定）
  • -XX:MaxTenuringThreshold :对象从年轻代晋升到老生代经过
    GC次数的最大阈值

老年代

存放生命周期较长的对象

  • Full GC和Major GC
  • Full GC比Minor GC慢,但执行频率低

触发Full GC的条件

  • 老年代空间不足
  • 永久代空间不足
  • CMS GC时出现promotion failed ,
    concurrent mode failure
  • Minor GC晋升到老年代的平均大小大于老年代的剩余空间
  • System.gc()
  • 使用RMI来进行RPC或管理的JDK应用,每小时执行1次Full GC

Stop-the-World

  • JVM由于要执行GC而停止了应用程序的执行
  • 任何一种GC算法中都会发生
  • 多数GC优化通过减少Stop-the -world发生的时间来提高程序性能（高吞吐，低停顿）

Safepoint

  • 分析过程中对象引用关系不会发生变化的点
  • 产生Safepoint的地方:方法调用;循环跳转;异常跳转等
  • 安全点数量得适中.

JVM的运行模式

  • Server
  • Client

三、常见的垃圾收集器

垃圾收集器之间的联系
HotSpot虚拟机垃圾收集器

图片来源：http://www.worldwarner.com/m/view.php?aid=18114

年轻代常见的垃圾收集器

Serial收集器( -XX:+UseSerialGC ,复制算法)

  • 单线程收集,进行垃圾收集时,必须暂停所有工作线程
  • 简单高效, Client模式下默认的年轻代收集器

ParNew收集器( -XX:+UseParNewGC ,复制算法)

  • 多线程收集,其余的行为、特点和Serial收集器一样
  • 单核执行效率不如Serial ,在多核下执行才有优势

Parallel Scavenge收集器( -XX:+UseParallelGC ,复制算法)

  • 比起关注用户线程停顿时间,更关注系统的吞吐量【吞吐量=运行用户代码时间/ (运行用户代码时间+垃圾收集时间)】
  • 在多核下执行才有优势, Server模式下默认的年轻代收集器

老年代常见的垃圾收集器

Serial Old收集器( -XX:+UseSerialOldGC ,标记-整理算法)

  • 单线程收集,进行垃圾收集时,必须暂停所有工作线程
  • 简单高效, Client模式下默认的老年代收集器

Parallel Old收集器( -XX : +UseParallelOldGC ,标记-整理算法)

  • 多线程,吞吐量优先

CMS收集器( -XX:+UseConcMarkSweepGC ,标记-清除算法)

  • 初始标记: stop-the-world
  • 并发标记:并发追溯标记,程序不会停顿
  • 并发预清理:查找执行并发标记阶段从年轻代晋升到老年代的对象
  • 重新标记:暂停虚拟机,扫描CMS堆中的剩余对象
  • 并发清理:清理垃圾对象,程序不会停顿
  • 并发重置:重置CMS收集器的数据结构

G1收集器( -XX:+UseG1GC,复制+标记-整理算法)

Garbage First收集器的特点

  • 并行和并发
  • 分代收集
  • 空间整合
  • 可预测的停顿

Garbage First收集器

  • 将整个Java堆内存划分成多个大小相等的Region
  • 年轻代和老年代不再物理隔离

GC相关的面试题

1、Object的finalize(方法的作用是否与C+ +的析构函数作用相同？

  • 与C++的析构函数不同,析构函数调用确定,而它的是不确定的
  • 将未被引用的对象放置于F-Queue队列
  • 方法执行随时可能会被终止
  • 给予对象最后一次重生的机会

代码示例：

package com.interview.javabasic.jvm.gc;

import java.lang.ref.ReferenceQueue;

public class Finalization {
    public static Finalization finalization;
    @Override
    protected void finalize(){
        System.out.println("Finalized");
        finalization = this;
    }

    public static void main(String[] args) {
        Finalization f = new Finalization();
        System.out.println("First print: " + f);
        f = null;
        System.gc();
        try {// 休息一段时间，让上面的垃圾回收线程执行完成
            Thread.currentThread().sleep(1000);
        } catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("Second print: " + f);
        System.out.println(f.finalization);
    }
}

运行结果：

First print: com.interview.javabasic.jvm.gc.Finalization@511d50c0
Finalized
Second print: null
com.interview.javabasic.jvm.gc.Finalization@511d50c0

2、Java中的强引用,软引用,弱引用,虚引用有什么用？

强引用( Strong Reference )

  • 最普遍的引用: Object obj=new Object()
  • 抛出OutOfMemoryError终止程序也不会回收具有强引用的对象
  • 通过将对象设置为null来弱化引用,使其被回收

软引用( Soft Reference )

  • 对象处在有用但非必须的状态
  • 只有当内存空间不足时, GC会回收该引用的对象的内存
  • 可以用来实现高速缓存

示例代码：

String str = new String("abc"); //强引用
SoftReference<String> softReference = new SoftReference<>(str); //软引用

弱引用( Weak Reference )

  • 非必须的对象,比软引用更弱一些
  • GC时会被回收
  • 被回收的概率也不大,因为GC线程优先级比较低
  • 适用于引用偶尔被使用且不影响垃圾收集的对象

示例代码：

String str = new String("abc"); //强引用
WeakReference<String> softReference = new WeakReference<>(str); //弱引用

虚引用( PhantomReference )

  • 不会决定对象的生命周期
  • 任何时候都可能被垃圾收集器回收
  • 跟踪对象被垃圾收集器回收的活动,起哨兵作用
  • 必须和引用队列ReferenceQueue联合使用

示例代码：

String str = new String("abc"); //强引用
ReferenceQueue queue = new ReferenceQueue();
PhantomReference reference = new PhantomReference(str, queue);

比较：

强引用>软引用>弱引用>虚引用

类层次结构：

引用队列( ReferenceQueue ) 7-6 (不太明白)

  • 无实际存储结构,存储逻辑依赖于内部节点之间的关系来表达
  • 存储关联的且被GC的软引用，弱引用以及虚引用

示例代码：

NormalObject类

package com.interview.javabasic.jvm.gc;

public class NormalObject {
    public String name;
    public NormalObject(String name){
        this.name = name;
    }

    @Override
    protected void finalize(){
        System.out.println("Finalizing obj " + name);
    }
}

NormalObjectWeakReference类

package com.interview.javabasic.jvm.gc;

import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;

public class NormalObjectWeakReference extends WeakReference<NormalObject> {
    public String name;

    public NormalObjectWeakReference(NormalObject normalObject, ReferenceQueue<NormalObject> rq) {
        super(normalObject, rq);
        this.name = normalObject.name;
    }
    @Override
    protected void finalize(){
        System.out.println("Finalizing NormalObjectWeakReference " + name);
    }
}

ReferenceQueueTest主类

package com.interview.javabasic.jvm.gc;

import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.util.ArrayList;

public class ReferenceQueueTest {
    private static ReferenceQueue<NormalObject> rq = new ReferenceQueue<NormalObject>();

    private static void checkQueue(){
        Reference<NormalObject> ref = null;
        while ((ref = (Reference<NormalObject>)rq.poll()) != null){
            if (ref != null){
                System.out.println("In queue: " + ((NormalObjectWeakReference)(ref)).name);
                System.out.println("reference object:" + ref.get());
            }
        }
    }

    public static void main(String[] args) {
        ArrayList<WeakReference<NormalObject>> weakList = new ArrayList<WeakReference<NormalObject>>();
        for (int i =0; i < 3 ; i++){
            weakList.add(new NormalObjectWeakReference(new NormalObject("Weak " + i),rq));
            System.out.println("Created weak:" + weakList.get(i));
        }
        System.out.println("first time");
        checkQueue();
        System.gc();
        try {
            Thread.currentThread().sleep(1000);
        } catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("second time");
        checkQueue();
    }
}

运行结果：

Created weak:com.interview.javabasic.jvm.gc.NormalObjectWeakReference@511d50c0
Created weak:com.interview.javabasic.jvm.gc.NormalObjectWeakReference@60e53b93
Created weak:com.interview.javabasic.jvm.gc.NormalObjectWeakReference@5e2de80c
first time
Finalizing obj Weak 2
Finalizing obj Weak 1
Finalizing obj Weak 0
second time
In queue: Weak 0
reference object:null
In queue: Weak 2
reference object:null
In queue: Weak 1
reference object:null
GC
评论
评论
  目录