强引用，软引用，弱引用，虚引用

目录

1 引用的整体架构

2 强引用(Reference)，默认支持模式

2.1 概念

2.2 DEMO-强引用测试

3 软引用 softReference

3.1 概念

3.2 DEMO-软引用

3.2.1 DEMO-内存够的情况

3.2.2 DEMO-内存不够的情况

4 弱引用（WeakReference）

4.1 概念

4.2 DEMO- 软引用WeakReference

5 虚引用（幽灵引用，PhantomReference）

5.1 引用对列

5.1.1 DEMO-引用队列使用

5.2 虚引用使用

5.2.1 DEMO-虚引用

6 软引用和若引用的适用场景

7 WeakHashMap

7.1 DEMO-HashMap

7.2 DEMO-WeakHashMap

8 小总结

---

1 引用的整体架构

2 强引用(Reference)，默认支持模式

Book b1 = new Book();

一般这个就是强引用(Reference)

2.1 概念

当内存不足，JVM开始垃圾回收。对于强引用的对象，就算是出现了OOM也不会对该对象进行回收，死都不收。

强引用是我们最常见的普通对象引用，只要还有强引用指向一个对象，就能表明对象还“活着”，垃圾收集器不会碰着这种对象。

在java中最常见的就是强引用，把一个对象赋给一个引用变量，这个引用变量就是一个强引用。

当一个对象被强引用变量引用时，它处于可达状态，它是不可能被垃圾回收机制回收的，即使对象以后都不会被用到，JVM也不会回收。因此强引用时造成JAVA内存泄漏的主要原因之一。

对于一个普通的对象，如果没有其它的引用关系，只要超过了引用的作用域或者显式的将相应（强）引用赋值为null,一般认为就是可以被垃圾收集的了（具体回收时机要看垃圾收集策略）

2.2 DEMO-强引用测试

public class StrongReferenceDemo {
    public static void main(String[] args) {
        //强引用定义
        Object obj1 = new Object();
        //obj2引用赋值
        Object obj2 = obj1;
        //置空
        obj1 = null;
        System.gc();
        System.out.println(obj2);
    }
}

输出;

java.lang.Object@4554617c

可以看出因为obj2也是强引用，没有被回收。

死了都不回收

3 软引用 softReference

内存够的时候不收，内存不够的情况下回收，尽量不导致内存不够用。

3.1 概念

软引用是一种相对强引用弱化了一些的引用，需要用java.lang.ref.SoftReference类来实现，可以让对象豁免一些垃圾收集。

对于只有软引用的对象来说：

当系统内存充足时，它不会被回收。

当系统内存不足时，会被回收。

软引用通常用在对内存敏感的程序中，比如高速缓存，内存够就保留，不够就回收。

应用场景：

mybatis底层的一些代码就是softReference类实现的

官方说明：

3.2 DEMO-软引用

3.2.1 DEMO-内存够的情况

public class SoftReferenceDemo {
    //内存够用的时候保留，不够时回收
    public static void softRef_Memory_Enough() {
        Object o1 = new Object();
        SoftReference<Object> softReference = new SoftReference<>(o1);
        System.out.println(o1);
        System.out.println(softReference.get());

        o1 = null;
        System.gc();
        System.out.println(o1);
        System.out.println(softReference.get());
    }


    public static void main(String[] args) {
        softRef_Memory_Enough();
    }
}

输出

java.lang.Object@4554617c
java.lang.Object@4554617c
null
java.lang.Object@4554617c

3.2.2 DEMO-内存不够的情况

public class SoftReferenceDemo {
    /**
     * JVM配置，故意产生大对象并配置小内存，让它内存不够用导致OOM，看软引用回收情况
     * -Xms5m -Xmx5m -XX:+PrintGCDetails
     */
    public static void softRef_Memory_NotEnough() {
        Object o1 = new Object();
        SoftReference<Object> softReference = new SoftReference<>(o1);
        System.out.println(o1);
        System.out.println(softReference.get());

        o1 = null;

        try {
            byte[] bytes = new byte[30*1024*1024];
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println(o1);
            System.out.println(softReference.get());
        }
    }

    public static void main(String[] args) {
        softRef_Memory_NotEnough();
    }
}

输出

可以看出，因为内存不够，自动GC了。

4 弱引用（WeakReference）

不管内存是否够用，GC一律回收。

4.1 概念

弱引用需要用java.lang.ref.WeakReference类来实现，它比软引用的生命周期的生命期更短。

对于只有弱引用的对象来说，只要垃圾回收机制一运行，不管JVM内存空间是否足够，都会回收该对象的内存。

4.2 DEMO- 软引用WeakReference

public class WeakReferenceDemo {
    public static void main(String[] args) {
        Object o1 = new Object();
        WeakReference<Object> weakReference = new WeakReference<>(o1);
        System.out.println(o1);
        System.out.println(weakReference.get());

        o1=null;
        System.gc();

        System.out.println("===========以下输出在GC之后");
        System.out.println(o1);
        System.out.println(weakReference.get());
    }
}

输出

java.lang.Object@4554617c
java.lang.Object@4554617c
===========以下输出在GC之后
null
null

Process finished with exit code 0

可以看出引用都被回收了。

高速缓存用软弱引用

5 虚引用（幽灵引用，PhantomReference）

虚引用需要java.lang.ref.PhantomReference类来实现。

顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。

如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。它不能单独使用也不能通过它访问对象，虚引用必须和引用队列（ReferenceQueue）联合使用。

虚引用的作用：

跟踪对象被垃圾回收的状态。仅仅是提供了一宗确保对象被finalize以后，做某些事情的机制（也就是对象回收前，数据放引用队列里，在死前做利用这些数据做最后的处理）

PhantomReference的get方法总是返回null，因此无法访问对应的引用对象，其意义在于说明一个对象已经进入finalization阶段，可以被GC回收，用于实现比finalization机制更灵活的回收操作。

即，设置虚引用关联的唯一目的：

在对象被收集器回收的时候，收到一个系统通知或者后续添加进一步的处理。

JAVA技术允许使用finalize()方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。

小总结：

get总是null, 要和引用队列配合使用。

用于对象回收的监控

5.1 引用对列

被回收前，需要被引用队列保存一下。

以WeakReference举例，可以看到两个方法，后者传参多了一个队列：

5.1.1 DEMO-引用队列使用

public class ReferenceQueueDemo {
    public static void main(String[] args) throws InterruptedException {
        Object o1 = new Object();
        ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();
        WeakReference<Object> weakReference = new WeakReference<>(o1, referenceQueue);

        System.out.println(o1);
        System.out.println(weakReference.get());
        System.out.println(referenceQueue.poll());

        System.out.println("===========以下输出在GC之前");

        o1 = null;
        System.gc();
        Thread.sleep(5);

        System.out.println(o1);
        System.out.println(weakReference.get());
        System.out.println(referenceQueue.poll());
    }
}

输出

java.lang.Object@4554617c
java.lang.Object@4554617c
null
===========以下输出在GC之前
null
null
java.lang.ref.WeakReference@74a14482

Process finished with exit code 0

GC之前，会把数据放到引用队列中。

5.2 虚引用使用

监控对象回收信息，可以用引用队列执行一些后置通知。

5.2.1 DEMO-虚引用

public class PhantReferenceDemo {
    public static void main(String[] args) throws InterruptedException {
        Object o1 = new Object();
        ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();
        PhantomReference<Object> phantomReference = new PhantomReference<>(o1, referenceQueue);

        System.out.println(o1);
        System.out.println(phantomReference.get());
        System.out.println(referenceQueue.poll());

        System.out.println("===========以下输出在GC之前");

        o1 = null;
        System.gc();
        Thread.sleep(5);

        System.out.println(o1);
        System.out.println(phantomReference.get());
        System.out.println(referenceQueue.poll());
    }
}

java.lang.Object@4554617c  //数据
null  //虚引用get都是空
null  //引用队列是空
===========以上输出在GC之前
null  //数据为空
null  //虚引用get都是空
java.lang.ref.PhantomReference@74a14482  //引用队列

Process finished with exit code 0

6 软引用和若引用的适用场景

此时可以用软引用或引用解决。

bitmap 位图索引

7 WeakHashMap

Hash table基于Map接口所实现的， 随着weak  keys, 对于用hashmap修饰的entry键值对将会自动被移除，当key不再按照正常情况使用，也就是key置空，会被垃圾回收。

7.1 DEMO-HashMap

public class WeakHashMapDemo {
    public static void main(String[] args) {
        myHashMap();
    }

    private static void myHashMap() {
        HashMap<Integer, String> map = new HashMap<>();
        Integer key = new Integer(1);
        String value = "HashMap";

        map.put(key, value);
        System.out.println(map);

        key = null;
        System.out.println(map);

        System.gc();
        System.out.println(map);
    }
}

输出

{1=HashMap}
{1=HashMap}
{1=HashMap}

Process finished with exit code 0

7.2 DEMO-WeakHashMap

public class WeakHashMapDemo {
    public static void main(String[] args) {
        myWeakHashMap();
    }

    private static void myWeakHashMap() {
        WeakHashMap<Integer, String> map = new WeakHashMap<>();
        Integer key = new Integer(2);
        String value = "HashMap";

        map.put(key, value);
        System.out.println(map);

        key = null;
        System.out.println(map);

        System.gc();
        System.out.println(map);
    }
}

输出

{2=HashMap}
{2=HashMap}
{}

Process finished with exit code 0

可以看出gc后，被回收了

之所以key = null后map还有值，是因为map底层是node<k,v>,map指向到了new Integer(2)，是强引用。

一般用来做缓存，只要GC，就会被移除，减少OOM溢出的概率降低。

8 小总结

红色对象，黑色实心箭头的是强引用，不被回收

蓝色对象，蓝色箭头，内存够，不回收，内存不够，回收

- - ->弱引用指向对象， GC就回收

虚引用指向对象，GC后放入引用队列中，可作为一些通知机制使用

非GC ROOT SET中引用的，都是引用不可达，都会被回收。

参考文献

以上内容均来自于下方视频，博客内容仅作为个人学习笔记记录

Java面试_高频重点面试题 （第一、二、三季）_ 面试 第1、2、3季_柴林燕_周阳_哔哩哔哩_bilibili