一文详解Java中的垃圾回收机制

电玩女神 2024-03-22 09:57 106阅读 0赞

## 垃圾回收 ##

### 如何判断对象可以回收 ###

#### 可达性分析算法 ####

Java 虚拟机的垃圾回收器根据 **可达性分析算法** 来探索存货的对象

扫描堆中的对象，看是否能够沿着 **GC Root 对象**为起点的引用链找到该对象，若找不到，则回收对象

#### 四种引用 ####

强引用

只有所有 GC Root 对象不通过强引用来引用该对象时，这个对象才会被垃圾回收

软引用

*  仅有软引用引用该对象时，在**垃圾回收后**，**内存不足**时会**再次**进行垃圾回收，释放被软引用引用的对象
 *  可以配合引用队列来使用

设置堆内存为 16m：-Xmx16m，内存不足报错

public static void main(String[] args) {
    
        int _4MB = 4 * 1024 * 1024;
        List<byte[]> bytes = new ArrayList<byte[]>();
        for(int i = 0; i < 5; i++) {
            byte[] bytes1 = new byte[_4MB];
            System.out.println(i);
            System.out.println(bytes1);
            bytes.add(bytes1);
        }
    }
    复制代码

使用软引用

public static void soft() throws IOException {
        int _4MB = 4 * 1024 * 1024;
        List<SoftReference<byte[]>> softReferences = new ArrayList<>();
        
        for(int i = 0; i < 5; i++) {
            System.out.println(i);
            SoftReference<byte[]> softReference = new SoftReference<>(new byte[_4MB]);
            softReferences.add(softReference);
            System.out.println(softReference.get());
        }
        
        for (SoftReference<byte[]> reference : softReferences) {
            System.out.println(reference.get());
        }
    }
    复制代码

使用软引用配合引用队列：软引用引用的对象被回收后，该软引用对象会被写入到引用队列中去，只需要在`softReferences`中清除软引用队列中含有的对象即可

public static void clearSoft() {
        int _4MB = 4 * 1024 * 1024;
        List<SoftReference<byte[]>> softReferences = new ArrayList<>();
        
        // 软引用队列
        ReferenceQueue<byte[]> softReferenceReferenceQueue = new ReferenceQueue<>();
        for(int i = 0; i < 5; i++) {
            System.out.println(i);
            // 当软引用引用的对象被回收后，该软引用会被存储到 softReferenceReferenceQueue 中
            SoftReference<byte[]> softReference = new SoftReference<>(new byte[_4MB],softReferenceReferenceQueue);
            softReferences.add(softReference);
            System.out.println(softReference.get());
        }
    
        // 清除软引用对象
        Reference<? extends byte[]> poll = softReferenceReferenceQueue.poll();
        while (poll != null) {
            softReferences.remove(poll);
            poll = softReferenceReferenceQueue.poll();
        }
    
        for (SoftReference<byte[]> reference : softReferences) {
            System.out.println(reference.get());
        }
    }
    复制代码

弱引用

*  仅用虚引用引用该对象，在垃圾回收时，不管内存是否足够，都会回收被虚引用引用的对象
 *  可以配合引用队列来使用

public static void weak() {
        int _4MB = 4 * 1024 * 1024;
        // 创建 GC Root 对象
        List<WeakReference<byte[]>> weakReferences = new ArrayList<>();
    
        for(int i = 0; i < 5; i++) {
            // 创建虚引用对象
            WeakReference<byte[]> weakReference = new WeakReference<>(new byte[_4MB]);
            boolean add = weakReferences.add(weakReference);
            System.out.println(weakReference.get());
        }
    
    
        for (WeakReference<byte[]> weakReference : weakReferences) {
            System.out.println(weakReference.get());
        }
    }
    复制代码

虚引用

*  必须配合引用队列使用，主要配合 bytebuffer 使用，被引用对象回收时，会将虚引用入队，由 reference handler 线程调用虚引用相关方法释放内存

终结器引用

*  无需手动编码，但其内部配合引用队列使用，在垃圾回收时，终结器引用入队（被引用的对象暂时没有被回收），再由 finalizer 线程通过终结器引用找到对象并调用它的 finalize 方法，第二次 GC 时才能回收该对象

![format_png][]

### 垃圾回收算法 ###

#### 标记清除 ####

1.  找出没有被 GC Root 引用的对象，打上标记
2.  清除没有被 GC Root 引用的对象

![format_png 1][]

特点：

1.  速度快；
2.  容易造成大量的**内存碎片**

#### 标记整理 ####

1.  找出没有被 GC Root 引用的对象，打上标记
2.  清除被标记的对象
3.  整理内存块，减少碎片

![format_png 2][]

特点：

1.  速度慢
2.  不存在内存碎片

#### 复制 ####

1.  找出没有被 GC Root 引用的对象，打上标记；
2.  存在两个内存块 from 和 to；
3.  将没有被标记的对象从 from 移动到 to 中，接着清除 from 中的对象；
4.  交换 from 和 to 的内容；

![format_png 3][]

特点：

1.  不会产生内存碎片；
2.  占用双倍的内存空间；

### 分代垃圾回收 ###

Java 中**堆内存**的区域划分为 **新生代** 和 **老年代**

**新生代**：存放生命周期**较短**的对象，分为**伊甸园**，**幸存区 From**，**幸存区 To**；

**老年代**：存放生命周期**较长**的对象，有价值，长时间存在的对象；

![format_png 4][]

#### 回收过程 ####

1.  新产生的对象放在**伊甸园**中，若新生代的空间不足，则会发生一次 **Minor gc**，会发生一次 **stop the world**

stop the world 暂停用户线程，因为对象的复制和内存的整理会导致某些对象的内存地址发生了改变，多个线程访问会造成混乱，等垃圾回收结束，用户线程才继续进行

1.  Minor gc 将伊甸园和幸存区 From 中幸存的对象**复制**（使用复制算法）到幸存区 To 中，然后交换幸存区 From 和 To

Minor gc **扫描的范围包括 伊甸园 和幸存区 From**

1.  幸存的对象会将自己的寿命加 1，若该寿命超过了阈值（15，使用 4 bit 存储），则会将该对象**晋升到老年代**中

![format_png 5][]

1.  当老年代的空间不足，则先尝试进行 Minor gc \[ 因为对象是要先插入伊甸园中的 \]，如果之后空间仍然不足，则会发生 **Full gc**，Full gc 也会产生一次 stop the world

![format_png 6][]

1.  如果空间仍然不足，则会产生 OutOfMemoryError

### 垃圾回收器 ###

1.  串行

1.  1.  单核 CPU
    2.  堆内存较少

1.  吞吐量优先

1.  1.  多线程
    2.  堆内存较大
    3.  单位时间内，STW 的时间最短

1.  响应时间优先

1.  1.  多线程
    2.  堆内存较大
    3.  每次 STW 的时间最短

#### 串行垃圾回收器 ####

在垃圾回收时：保证只有一个 GC 线程运行

GC参数：`-XX:+UseSerialGC = Serial + Serialold` 新生代采用**复制**算法，老年代采用**标记整理**算法

![format_png 7][]

#### 吞吐量优先垃圾回收器 ####

多个线程进行垃圾回收

GC 参数：`-XX:+UseParallelGC~-XX:+UseParallelOldGC`，新生代采用**复制**算法，老年代采用**标记整理**算法

![format_png 8][]

#### 基于响应时间的垃圾回收器 ####

GC参数：`-XX:+UseConcMarkSweepGC~-XX:+UseParNewGC ~ SerialOld`

新生代采用复制算法，老年代采用标记清除算法，速度快

![format_png 9][]

[format_png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/612d4b2a015e4e4283460d8ad2cca08a.png
[format_png 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/6f8187e8d700402fb82b945e249d6cc3.png
[format_png 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/3d247c30642c430ca91e3d716503c8d4.png
[format_png 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/7922fe862bcc4910a0668962802fe8ba.png
[format_png 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/d5d228ce04ea4a2684f307ef05814f01.png
[format_png 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/1ab2b720b76349378869a039bb6d3380.png
[format_png 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/26606ecc698c4066bca5596ff08cbe54.png
[format_png 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/1f6903c4b0bb433199933cfe5bb3243d.png
[format_png 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/ef72ab76b3dd46aa91a3ebbca1f8ec3f.png
[format_png 9]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/11bf76d047864f1f96c5e7be8216fe4f.png