java开发规范面试，【JVM】垃圾回收

最新推荐文章于 2024-10-07 19:55:44 发布

2401_84010362

最新推荐文章于 2024-10-07 19:55:44 发布

阅读量536

点赞数 30

分类专栏：程序员文章标签： jvm java 面试

本文链接：https://blog.csdn.net/2401_84010362/article/details/137849887

版权

程序员专栏收录该内容

196 篇文章 0 订阅

订阅专栏

- 1.如何判断对象可以回收
- 1-1 引用计数法
1-2 可达性分析算法
1-3 五种引用
2.垃圾回收算法
- 2-1 标记清除
2-2 标记整理
2-3 复制
3.分代垃圾回收
- 3-1 回收流程
3-2 GC 分析
4.垃圾回收器
- 4-1 串行
4-2 吞吐量优先
4-3 响应时间优先
4-4 G1
5.垃圾回收调优
- 5-1 调优领域
5-2 确定目标
5-3 最快的 GC
5-4 新生代调优
5-5 老年代调优

JVM-垃圾回收

=======================================================================

本文章参考：黑马程序员JVM

1.如何判断对象可以回收

1-1 引用计数法

当一个对象被其他变量引用，该对象计数加一，当某个变量不在引用该对象，其计数减一
当一个对象引用没有被其他变量引用时，即计数变为0时，该对象就可以被回收

缺点：循环引用时，两个对象的计数都为1，导致两个对象都无法被释放

1-2 可达性分析算法

JVM中的垃圾回收器通过可达性分析来探索所有存活的对象
扫描堆中的对象，看能否沿着GC Root对象为起点的引用链找到该对象，如果找不到，则表示可以回收
可以作为GC Root的对象
虚拟机栈（栈帧中的本地变量表）中引用的对象。
方法区中类静态属性引用的对象
方法区中常量引用的对象
本地方法栈中JNI（即一般说的Native方法）引用的对象
所有被同步锁（synchronized关键字）持有的对象。

1-3 五种引用

强引用

只有所有 GC Roots 对象都不通过【强引用】引用该对象，该对象才能被垃圾回收

软引用

仅有【软引用】引用该对象时，在垃圾回收后，内存仍不足时会再次出发垃圾回收，回收软引用对象
可以配合【引用队列】来释放软引用自身

弱引用

仅有【弱引用】引用该对象时，在垃圾回收时，无论内存是否充足，都会回收弱引用对象
可以配合【引用队列】来释放弱引用自身

虚引用

必须配合【引用队列】使用，主要配合 ByteBuffer 使用，被引用对象回收时，会将【虚引用】入队，由 Reference Handler 线程调用虚引用相关方法释放【直接内存】
如上图，B对象不再引用ByteBuffer对象，ByteBuffer就会被回收。但是直接内存中的内存还未被回收。这时需要将虚引用对象Cleaner放入引用队列中，然后调用它的clean方法来释放直接内存

终结器引用

无需手动编码，但其内部配合【引用队列】使用，在垃圾回收时，【终结器引用】入队（被引用对象暂时没有被回收），再由 Finalizer 线程通过【终结器引用】找到被引用对象并调用它的 finalize 方法，第二次 GC 时才能回收被引用对象
如上图，B对象不再引用A4对象。这时终结器对象就会被放入引用队列中，引用队列会根据它，找到它所引用的对象。然后调用被引用对象的finalize方法。调用以后，该对象就可以被垃圾回收了

软引用使用：

public class Demo1 {

public static void main(String[] args) {

final int _4M = 410241024;

//使用软引用对象 list和SoftReference是强引用，而SoftReference和byte数组则是软引用

List<SoftReference<byte[]>> list = new ArrayList<>();

SoftReference<byte[]> ref= new SoftReference<>(new byte[_4M]);

}

软引用_引用队列使用：

public static void main(String[] args) throws IOException {

///使用引用队列，用于移除引用为空的软引用对象

ReferenceQueue<byte[]> queue=new ReferenceQueue<>();

//使用软引用对象 list和SoftReference是强引用，而SoftReference和byte数组则是软引用

List<SoftReference<byte[]>> list = new ArrayList<>();

for (int i = 0; i < 5; i++) {

//关联了引用队列,当软引用所关联的byte数组被回收时，软引用自己就会加入到引用队列queue 中去

SoftReference<byte[]> ref = new SoftReference<>(new byte[_4MB],queue);

System.out.println(ref.get());

list.add(ref);

System.out.println(list.size());

}

//获取队列中第一个软引用对象

Reference<? extends byte[]> poll = queue.poll();

//遍历引用队列，如果有元素，则移除

while(poll!=null){

list.remove(poll);

poll=queue.poll();

}

System.out.println(“=============”);

System.out.println(“循环结束：” + list.size());

for (SoftReference<byte[]> ref : list) {

System.out.println(ref.get());

}

弱引用使用：

弱引用的使用和软引用类似，只是将 SoftReference 换为了 WeakReference

public static void main(String[] args) {

//使用弱引用对象 list和SoftReference是强引用，而SoftReference和byte数组则是弱引用

List<WeakReference<byte[]>> list=new ArrayList<>();

for (int i = 0; i < 5; i++) {

WeakReference<byte[]> ref=new WeakReference<>(new byte[_4MB]);

list.add(ref);

for (WeakReference<byte[]> w : list) {

System.out.print(w.get()+" ");

}

System.out.println();

}

System.out.println(“循环结束：”+list.size());

}

2.垃圾回收算法

2-1 标记清除

定义：在虚拟机执行垃圾回收的过程中，先采用标记算法确定可回收对象，然后垃圾收集器根据标识清除相应的内容，给堆内存腾出相应的空间

注意：这里的清除并不是将内存空间字节清零，而是记录这段内存的起始地址，下次分配内存的时候，会直接覆盖这段内存。

优点：速度快

缺点：容易产生内存碎片。一旦分配较大内存的对象，由于内存不连续，导致无法分配，最后就会造成内存溢出问题

2-2 标记整理

定义：在虚拟机执行垃圾回收的过程中，先采用标记算法确定可回收对象，然后整理剩余的对象，将可用的对象移动到一起，使内存更加紧凑，连续的空间就更多。

优点：不会有内存碎片

缺点：速度慢

2-3 复制

定义：将内存分为等大小的两个区域，FROM和TO（TO中为空）。将被GC Root引用的对象从FROM放入TO中，再回收不被GC Root引用的对象。然后交换FROM和TO。这样也可以避免内存碎片的问题，但是会占用双倍的内存空间。

优点：不会有内存碎片

缺点：会占用双倍的内存空间。

3.分代垃圾回收

将堆内存分为新生代和老年代，新生代有划分为伊甸园，幸存区To，幸存区From。

3-1 回收流程

对象首先分配在伊甸园区域

新生代空间不足时，触发 Minor GC，伊甸园和 from 存活的对象使用 copy 复制到 to 中，存活的对象年龄加 1并且交换 from to

再次创建对象，若新生代的伊甸园又满了，则会再次触发 Minor GC（minor gc 会引发 stop the world，暂停其它用户的线程，等垃圾回收结束，用户线程才恢复运行），这时不仅会回收伊甸园中的垃圾，还会回收幸存区中的垃圾，再将活跃对象复制到幸存区TO中。回收以后会交换两个幸存区，并让幸存区中的对象寿命加1

在这里插入图片描述

当对象寿命超过阈值时，会晋升至老年代，最大寿命是15（4bit）

当老年代空间不足，会先尝试触发Minor GC，如果之后空间仍不足，那么触发 Full GC，stop the world的时间更长

3-2 GC 分析

相关VM参数

| 含义 | 参数 |

| — | — |

| 堆初始大小 | -Xms |

| 堆最大大小 | -Xmx 或 -XX:MaxHeapSize=size |

| 新生代大小 | -Xmn 或 (-XX:NewSize=size + -XX:MaxNewSize=size ) |

| 幸存区比例（动态） | -XX:InitialSurvivorRatio=ratio 和 -XX:+UseAdaptiveSizePolicy |

| 幸存区比例 | -XX:SurvivorRatio=ratio |

| 晋升阈值 | -XX:MaxTenuringThreshold=threshold |

| 晋升详情 | -XX:+PrintTenuringDistribution |

| GC详情 | -XX:+PrintGCDetails -verbose:gc |

| FullGC 前 MinorGC | XX:+ScavengeBeforeFullGC |

大对象处理策略

遇到一个较大的对象时，就算新生代的伊甸园为空，也无法容纳该对象时，会将该对象直接晋升为老年代

/**

演示内存的分配策略

public class Main {

private static final int _512KB = 512 * 1024;

private static final int _1MB = 1024 * 1024;

private static final int _6MB = 6 * 1024 * 1024;

private static final int _7MB = 7 * 1024 * 1024;

private static final int _8MB = 8 * 1024 * 1024;

// -Xms20M -Xmx20M -Xmn10M -XX:+UseSerialGC -XX:+PrintGCDetails -verbose:gc -XX:-ScavengeBeforeFullGC

public static void main(String[] args) throws InterruptedException {

ArrayList<byte[]> list=new ArrayList<>();

list.add(new byte[_8MB]);

}

在这里插入图片描述

线程内存溢出

某个线程的内存溢出了而抛异常（out of memory），不会让其他的线程结束运行。这是因为当一个线程抛出OOM异常后，它所占据的内存资源会全部被释放掉，从而不会影响其他线程的运行，进程依然正常

/**

演示内存的分配策略

public class Main {

private static final int _512KB = 512 * 1024;

private static final int _1MB = 1024 * 1024;

private static final int _6MB = 6 * 1024 * 1024;

private static final int _7MB = 7 * 1024 * 1024;

private static final int _8MB = 8 * 1024 * 1024;

// -Xms20M -Xmx20M -Xmn10M -XX:+UseSerialGC -XX:+PrintGCDetails -verbose:gc -XX:-ScavengeBeforeFullGC

public static void main(String[] args) throws InterruptedException {

new Thread(() -> {

ArrayList<byte[]> list = new ArrayList<>();

list.add(new byte[_8MB]);

}).start();

//主线程还是会正常执行

System.out.println(“sleep…”);

Thread.sleep(1000L);

}

在这里插入图片描述

4.垃圾回收器

相关概念：

并行收集：指多条垃圾收集线程并行工作，但此时用户线程仍处于等待状态
并发收集：指用户线程与垃圾收集线程同时工作（不一定是并行的可能会交替执行）。用户程序在继续运行，而垃圾收集程序运行在另一个CPU上
吞吐量：即CPU用于运行用户代码的时间与CPU总消耗时间的比值（吞吐量 = 运行用户代码时间 / ( 运行用户代码时间 + 垃圾收集时间 )），也就是。例如：虚拟机共运行100分钟，垃圾收集器花掉1分钟，那么吞吐量就是99%