垃圾回收相关概念概述

垃圾回收相关概念概述

1. 内存溢出（OOM）
   （1）没有空闲内存，并且垃圾收集器也无法提供更多内存
   （2）没有空闲内存的情况
   ① Java虚拟机的堆内存设置不够，可通过参数-Xms和-Xmx调整
   ② 代码中创建了大量大对象，并且长时间不能被垃圾收集器收集（存在被引用）
   当我们不断添加新类型的时候，永久代在运行时存在大量动态类型生成的场合：类似intern字符串缓存会占用太多空间，会导致OOM问题，后面元数据区的引入，直接内存不足也会导致OOM
2. 内存泄漏（Memory Leak）
   （1）只有对象不会再被程序用到了，但GC又不能回收他们的情况，叫做内存泄漏，很多时候，一些不太好的实践会导致对象的生命周期变长甚至出现OOM，这种现象也叫做宽泛意义上的内存泄漏
   （2）案例
   
   ① 单例模式
   单例的生命周期和程序是一样长的，所以单例程序中，如果持有对外部对象的引用的话，那么这个外部对象是不能回收的，会导致内存泄漏
   ② 一些需要close的资源未关闭导致内存泄漏
3. STW
   stop-the-word，简称STW，指的是GC事件发生过程中，会产生应用程序的停顿。停顿产生时，整个应用程序都会被暂停，没有任何响应。
4. 垃圾回收的并行和并发
   （1）并行：指多条垃圾收集线程同时工作，此时用户线程出于等待状态
   （2）并发：指用户线程和垃圾收集线程同时执行，但不一定是并行的，可能会交替执行，垃圾回收线程在执行时不会停顿用用户程序的运行
5. 引用
   （1）强引用-不回收
   ① 使用new操作符创建一个新的对象并将其赋值给一个变量时，这个变量就成为了指向该对象的一个强引用
   ② 强引用的对象是可触及的，垃圾收集器就永远不会回收掉被引用的对象，强引用是造成Java内存泄漏的主要原因之一
   （2）软引用-内存不足即回收
   ① 软引用用来描述一些还有用但非必须的对象，只被软引用关联着的对象在系统将要发生内存溢出前，会把这些对象列进回收范围之中进行第二次回收，如果回收还没有足够的内存，才会抛出内存溢出异常
   ② 当内存足够，不会回收软引用的可达对象；当内存不够会回收软引用的可达对象
   （3）弱引用-发现即回收
   ① 弱引用也是描述那些非必须的对象**，只被引用关联的对象只能生存到下一次垃圾收集发生为止，只要发现弱引用，GC都会回收掉**
   ② 由于垃圾回收器的线程通常优先级很低，这种情况下，弱引用对象就可以存在较长的时间
   ③ 弱引用与软引用最大不同在于，软引用在GC进行回收时，需要通过算法检查是否可以回收，而弱引用一经发现就会被回收
   （4）虚引用-对象回收跟踪
   ① 虚引用不能单独使用，也无法通过虚引用来获取被引用的对象，当试图通过虚引用的get方法取得对象时总是null
   ② 为一个对象设置虚引用关联的唯一目的在于跟踪垃圾回收过程，例如能在这个对象被收集器回收时收到一个系统通知
   ③ 虚引用必须和引用队列一起使用，虚引用创建时必须要提供一个引用队列作为参数。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象后将这个虚引用加入引用队列，来通知应用程序对象的回收情况
   ④ 由于虚引用可以跟踪对象的回收时间，也可以将一些资源释放操作放置在虚引用中个执行和记录
   ⑤ 案例

public class PhantomReferenceTest {
    public static PhantomReferenceTest obj;//当前类对象的声明
    static ReferenceQueue<PhantomReferenceTest> phantomQueue = null;//引用队列

    public static class CheckRefQueue extends Thread {
        @Override
        public void run() {
            while (true) {
                if (phantomQueue != null) {
                    PhantomReference<PhantomReferenceTest> objt = null;
                    try {
                        objt = (PhantomReference<PhantomReferenceTest>) phantomQueue.remove();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    if (objt != null) {
                        System.out.println("追踪垃圾回收过程：PhantomReferenceTest实例被GC了");
                    }
                }
            }
        }
    }

    @Override
    protected void finalize() throws Throwable { //finalize()方法只能被调用一次！
        super.finalize();
        System.out.println("调用当前类的finalize()方法");
        obj = this;
    }

    public static void main(String[] args) {
        Thread t = new CheckRefQueue();
        t.setDaemon(true);//设置为守护线程：当程序中没有非守护线程时，守护线程也就执行结束。
        t.start();

        phantomQueue = new ReferenceQueue<PhantomReferenceTest>();
        obj = new PhantomReferenceTest();
        //构造了 PhantomReferenceTest 对象的虚引用，并指定了引用队列
        PhantomReference<PhantomReferenceTest> phantomRef = new PhantomReference<PhantomReferenceTest>(obj, phantomQueue);

        try {
            //不可获取虚引用中的对象
            System.out.println(phantomRef.get());

            //将强引用去除
            obj = null;
            //第一次进行GC,由于对象可复活，GC无法回收该对象
            System.gc();
            Thread.sleep(1000);
            if (obj == null) {
                System.out.println("obj 是 null");
            } else {
                System.out.println("obj 可用");
            }
            System.out.println("第 2 次 gc");
            obj = null;
            System.gc(); //一旦将obj对象回收，就会将此虚引用存放到引用队列中。
            Thread.sleep(1000);
            if (obj == null) {
                System.out.println("obj 是 null");
            } else {
                System.out.println("obj 可用");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}