JVM学习笔记02:垃圾回收

垃圾回收

如何判断垃圾是否可以回收

1：引用计数法
当一个对象被引用时，就当引用对象的值加一，当值为 0 时，就表示该对象不被引用，可以被垃圾收集器回收。
这个引用计数法听起来不错，但是有一个弊端，如下图所示，循环引用时，两个对象的计数都为1，导致两个对象都无法被释放。
2：可达性分析算法

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

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

        ArrayList<Object> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add(1);
        System.out.println(1);
        System.in.read();

        list = null;
        System.out.println(2);
        System.in.read();
        System.out.println("end");
    }

引用类型

• 强引用
  只有所有 GC Roots 对象都不通过【强引用】引用该对象，该对象才能被垃圾回收
• 软引用（SoftReference）
  仅有软引用引用该对象时，在垃圾回收后，内存仍不足时会再次出发垃圾回收，回收软引用对象
  可以配合引用队列来释放软引用自身
• 弱引用（WeakReference）
  仅有弱引用引用该对象时，在垃圾回收时，无论内存是否充足，都会回收弱引用对象
  可以配合引用队列来释放弱引用自身
• 虚引用（PhantomReference）
  必须配合引用队列使用，主要配合 ByteBuffer 使用，被引用对象回收时，会将虚引用入队，
  由 Reference Handler 线程调用虚引用相关方法释放直接内存
• 终结器引用（FinalReference）
  无需手动编码，但其内部配合引用队列使用，在垃圾回收时，终结器引用入队（被引用对象暂时没有被回收），再由 Finalizer 线程通过终结器引用找到被引用对象并调用它的 finalize 方法，第二次 GC 时才能回收被引用对象。

演示弱引用

/**
 * 演示 软引用
 * -Xmx20m -XX:+PrintGCDetails -verbose:gc
 */
public class Code_08_SoftReferenceTest {

    public static int _4MB = 4 * 1024 * 1024;

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

    // 设置 -Xmx20m , 演示堆内存不足,
    public static void method1() throws IOException {
        ArrayList<byte[]> list = new ArrayList<>();

        for(int i = 0; i < 5; i++) {
            list.add(new byte[_4MB]);
        }
        System.in.read();
    }

    // 演示 软引用
    public static void method2() throws IOException {
        ArrayList<SoftReference<byte[]>> list = new ArrayList<>();
        for(int i = 0; i < 5; i++) {
            SoftReference<byte[]> ref = new SoftReference<>(new byte[_4MB]);
            System.out.println(ref.get());
            list.add(ref);
            System.out.println(list.size());
        }
        System.out.println("循环结束：" + list.size());
        for(SoftReference<byte[]> ref : list) {
            System.out.println(ref.get());
        }
    }
}

method1 方法解析： 首先会设置一个堆内存的大小为 20m，然后运行 mehtod1 方法，会抛异常，堆内存不足，因为 mehtod1
中的 list 都是强引用。

method2 方法解析：在 list 集合中存放了 软引用对象，当内存不足时，会触发 full gc，将软引用的对象回收。

上面的代码中，当软引用引用的对象被回收了，但是软引用还存在，所以，一般软引用需要搭配一个引用队列一起使用。
修改 method2

// 演示 软引用 搭配引用队列
    public static void method3() throws IOException {
        ArrayList<SoftReference<byte[]>> list = new ArrayList<>();
        // 引用队列
        ReferenceQueue<byte[]> queue = new ReferenceQueue<>();

        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("=====================");
        for(SoftReference<byte[]> ref : list) {
            System.out.println(ref.get());
        }
    }

垃圾回收算法

1：标记清除

概念：将垃圾回收分为两个阶段1 标记 2 清除

• 标记：从根节点开始标记引用的对象。
• 清除：未被标记引用的对象就是垃圾对象，，没有从root节点引用的对象都会被回收。可以被清理。

标记完成是的状态图

清除完后的图

内存碎片的产生

优点
可以看到标记清除算法解决了引用计数法中的循环引用的问题，没有从root节点引用的对象都会被回收。
缺点
标记和清除两个动作都需要遍历所有的对象，并且在GC时，需要停止应用程序，对于交互性要求比较高的应用而言这个体验是非常差的。
通过标记清除算法清理出来的内存，碎片化较为严重，因为被回收的对象可能存在于内存的各个角落，所有清理出来的内存是不连贯的。

2：标记整理

概念：标记-整理算法分为两个阶段：1.遍历GC Roots可达的对象，标记为已存活，如果不可达标记为未存活；2.将已存活的对象按照顺序排列在内存中，修改新的地址，将末端内存以后的对象清除掉

优点：结局了内存碎片问题
缺点：效率不高，对于标记-清除而言多了整理工作，对于复制算法而言多了标记工作

3：复制算法

概念：复制算法将内存分为一个有效内存区间和一个空闲内存空间,有效内存空间耗尽时JVM将暂停程序运行开启复制算法GC线程。GC线程会将活动区间内的存活对象，全部复制到空闲区间，且严格按照内存地址一次排列，与此同时，GC线程将更新存活对象的内存引用地址指向新的内存地址。这个时候空闲内存已经变成了活动区间，垃圾对象全部在原来的活动区间，清理掉垃圾对象，原活动区间就变成了空闲区间。

优点：很好地解决了标记-清除算法，内存布局混乱的缺点
缺点：浪费一半的内存。复制算法的GC过程就是重复的把对象复制一遍，而且将所有的引用地址重置一遍。可以预见的复制所消耗的时间随着对象存活率达到一定程度将会变成灾难。所以复制算法使用的场景是可以忍受只是用50%内存，对象存活率非常低

分代垃圾回收
清理过程

• 新创建的对象首先分配在 eden 区
• 新生代空间不足时，触发 minor gc ，eden 区 和 from 区存活的对象使用 - copy 复制到 to 中，存活的对象年龄加一，然后交换 from to
• minor gc 会引发 stop the world，暂停其他线程，等垃圾回收结束后，恢复用户线程运行
• 当幸存区对象的寿命超过阈值时，会晋升到老年代，最大的寿命是 15（4bit）
• 当老年代空间不足时，会先触发 minor gc，如果空间仍然不足，那么就触发 full fc ，停止的时间更长！