JVM垃圾回收（Hotspot）

叁歲伎倆 2023-10-03 09:16 16阅读 0赞

# 垃圾判断算法 #

> 程序计数器由于不会发生oom，所以不需要垃圾回收。虚拟机栈和本地方法栈随着线程的死亡而释放内存，所以也不需要垃圾回收。只有堆和方法区中内存的生命周期具有不确定性，需要垃圾回收管理。
> 
> 另外
> 
> 垃圾回收之前，需要找到垃圾。所以如何判断一个对象是垃圾是第一步。

## 引用计数算法 ##

> 在对象中添加一个引用计数器，每当有一个地方引用该对象时，计数器值就加1，当引用失效时，计数器值就减1。当一个对象的引用计数器值为0时，则可以判定该对象是垃圾。
> 
> 优点：引用计数法实现简单
> 
> 缺点：
> 
> 1.  需要耗费一点内存去记录对象被引用数
> 2.  存在两个对象相互引用的情况，即这两个对象的引用计数器值至少为1，造成内存泄漏

## 可达性分析算法 ##

### **GC Roots (根对象) 定义** ###

1.  虚拟机栈中引用的对象
2.  方法区中静态变量引用的对象
3.  方法区中常量引用的对象
4.  本地方法栈中JNI（Native方法）引用的对象
5.  Java虚拟机内部的引用
6.  同步锁持有的对象

总结一下GC Roots的特点：就是被堆外直接引用的堆内对象

### **跨代引用** ###

Hotspot堆内存是分代的，所以可能出现跨代引用，被跨代引用的堆对象其实也算是一种GC Root。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70][]

比如上面A,X,Y都是堆外直接引用的堆内对象，是常规的GC Root

但是B作为新生代对象，他没有被堆外直接引用，但是却被老年代对象X引用了（跨代引用），而老年代X是GC Root，所以B不是垃圾。

但是分代垃圾回收可以只对新生代进行回收（Minor GC），而垃圾回收前，需要查找被垃圾回收内存区域的GC Root,如果只考虑堆外直接引用堆内对象为GC Root的话，那么只有A是GC Root，B是垃圾。但是实际上B不是垃圾，所以我们可以将 代外直接引用的代内对象 也当成一种“分代级别”的GC Root.

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70 1][]

那么上面这种情况，B是否就是垃圾了？

整体来看，B确实是垃圾。但是如果只有新生代发生垃圾回收的话，B还是不会被回收，即B不会被当成垃圾。只有X被回收了，B才会被回收。所以我们可以将 代外直接引用的代内对象 也当成代GC Root.

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70 2][]

如果存在上面这种情况，X也存在跨代引用，则X也不能被当成垃圾。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70 3][]

如果发生上面这种情况，整体来看B,X都是垃圾，如果只发生老年代的垃圾回收(Majar GC),则X不会被垃圾回收。这样其实就造成了空间浪费。所以在回收老年代前，通常回收一次新生代，这样B就会被回收，之后X也会被回收。

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

从GC Roots（根对象）开始，根据引用关系向下搜索，搜索过程所走过的路径称为”引用链“，如果某个对象到GC Roots间没有任何引用链，则该对象可以判定为垃圾。

优点：两个对象相互引用时，也能被识别为垃圾。不需要对象保存引用计数信息。

缺点：当GC Roots数量过多时，该算法耗时较长。

## Java中的四种引用 ##

### **强引用（Strong Reference）** ###

当对象被一个或一个以上的引用变量引用时，它处于可达状态，不可能被垃圾回收。

### **软引用（Soft Reference）** ###

软引用需要通过SoftReference类来实现，当一个对象只有软引用时，它有可能被垃圾回收机制回收。对于只有软引用的对象而言，当系统内存足够时，它不会被系统回收，程序也可使用该对象；当系统内存不足时，系统可能会回收它。软引用通常用于对内存敏感的程序中。

// java -Xmx10m Main
    public class Main {
        public static void main(String[] args) {
            soft();
        }
    
        private static void soft(){
            SoftReference<byte[]> sf = new SoftReference<>(new byte[1024 * 1024 * 6]);
            System.out.println("======");
            SoftReference<byte[]> sf1 = new SoftReference<>(new byte[1024 * 1024 * 6]);
            System.out.println("======");
            System.out.println(sf.get());//null
            System.out.println(sf==null);//false
            System.out.println(sf1.get());//[B@1b6d3586
        }
    }

![20210626203601465.png][]

当一次Full GC后，堆内存任然不足时，会再次进行一次Full GC,将new byte\[1024 \* 1024 \* 6\]对象所占内存回收。

![20210626203801994.png][]

此时只剩下软引用对象new SoftReference()，因为它被sf强引用，所以无法被垃圾回收。

此时我们可以通过以下方式回收软引用对象new SoftReference()

if(sf.get()==null){
         sf = null;
    }

![20210626210023598.png][]

也可以借助另一种方式，SoftReference对象本身可以绑定一个引用队列ReferenceQueue对象，当软引用指向的对象被回收了，则软引用会被自动加入绑定的引用队列中。这种情况适用于要回收的软引用对象较多时。

import java.lang.ref.Reference;
    import java.lang.ref.ReferenceQueue;
    import java.lang.ref.SoftReference;
    import java.util.ArrayList;
    import java.util.List;
    
    public class Main {
        public static void main(String[] args){
            soft();
        }
    
        private static void soft(){
            ReferenceQueue<byte[]> queue = new ReferenceQueue<>();
    
            List<SoftReference<byte[]>> list = new ArrayList<>();
            list.add(new SoftReference<>(new byte[1024 * 1024],queue));
            list.add(new SoftReference<>(new byte[1024 * 1024 * 2],queue));
            list.add(new SoftReference<>(new byte[1024 * 1024 * 3],queue));
            list.add(new SoftReference<>(new byte[1024 * 1024 * 6],queue));
    
            Reference<? extends byte[]> poll = queue.poll();
            while (poll!=null){
                list.remove(poll);
                poll = queue.poll();
            }
    
            System.out.println(list.size());// 1
            list.forEach(t-> System.out.println(t.get()));// [B@404b9385
        }
    }

### **弱引用（Weak Reference）** ###

弱引用需要通过WeakReference类来实现，弱引用和软引用很想，但弱引用级别更低。对于只有弱引用的对象而言，当系统垃圾回收机制运行时，不管系统内存是否足够，总会回收该对象所占用的内存。

> 弱引用具体使用和软引用差不多，只是二者引用对象的回收时机不一样，只要发生垃圾回收，无论内存是否充足，都会回收弱引用引用的对象。

### **虚引用（Phantom Reference）** ###

虚引用通过PhantomReference类实现，虚引用完全类似于没有引用。虚引用对对象本身没有太大影响，对象甚至感觉不到虚引用的存在。如果一个对象只有虚引用时，那么它和没有引用的效果大致相同。虚引用主要用于跟踪对象被垃圾回收的状态，虚引用不能单独使用，虚引用必须和引用队列联合使用。

> 虚引用引用的对象不会因为内存不足而被垃圾回收，虚引用引用的对象和没有虚引用引用的对象效果相同。即虚引用并不是为了应对内存紧张场景。
> 
> 虚引用必须配合引用队列使用，因为虚引用引用的对象无法通过get()获取，所以无法判断虚引用引用的对象是否已经被回收。只能通过检查是否虚引用本身是否入队，若入队，则说明虚引用引用的对象已经被回收。
> 
> 由于虚引用引用的对象被回收后，会自动入队，所以只要检查队中是否有虚引用就可以跟踪对象被垃圾回收的状态。

public class Main {
        public static class Test{
            @Override
            protected void finalize() throws Throwable {
                System.out.println("finalize方法被调用");
                super.finalize();
            }
        }
    
        public static void main(String[] args){
            phantom();
        }
    
        private static void phantom(){
            ReferenceQueue<Test> queue = new ReferenceQueue<>();
    
            Test test = new Test();
            PhantomReference<Test> pr = new PhantomReference<>(test, queue);
            test = null;
    
            while (true){
                Reference<? extends Test> poll = queue.poll();
                if (poll!=null){
                    System.out.println(poll==pr);
                    break;
                } else {
                    System.out.println("=");
                    System.gc();
                }
            }
        }

# 垃圾回收算法 #

## 标记-清除 ##

## 标记-整理 ##

## 标记-复制 ##

# 分代垃圾回收 #

## 堆内存分代 ##

## 分代垃圾回收流程 ##

## 相关VM参数 ##

# 垃圾回收器 #

## 串行垃圾回收器 ##

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

## 响应时间垃圾回收器 ##

## G1垃圾回收器 ##

# 垃圾回收调优 #

## 调优目标 ##

## 代码审查 ##

## 新生代调优 ##

## 老年代调优 ##

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210625191725342.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210625192541844.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210625192824356.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20210625192937221.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA=,size_16,color_FFFFFF,t_70
[20210626203601465.png]: https://img-blog.csdnimg.cn/20210626203601465.png
[20210626203801994.png]: https://img-blog.csdnimg.cn/20210626203801994.png
[20210626210023598.png]: https://img-blog.csdnimg.cn/20210626210023598.png