java 强、软、弱、虚引用类型

引用类型

在jdk 1.2之前,一个对象只有 "已被引用" 和 "未被引用"两种概念,在jdk1.8之后,引用类型分为4类:
强引用:Strong Reference
软引用:Soft Reference
弱引用:Weak Reference
虚引用:Phantom Reference
这4中引用的强度依次减弱

强引用

java中默认的引用类型,只要引用存在,永远不会回收,哪怕内存不足,系统会抛出OOM异常,也不会回收。

软引用

只有当内存不足时,才会回收,回收后如果还是内存不足才会抛出OOM

private static void testSoftReference() {
        for (int i = 0; i < 10; i++) {
            byte[] buff = new byte[1024 * 1024];
            SoftReference sr = new SoftReference<>(buff);
            list.add(sr);
        }
        
        System.gc(); //主动通知垃圾回收
        
        for(int i=0; i < list.size(); i++){
            Object obj = ((SoftReference) list.get(i)).get();
            System.out.println(obj);
        }
        
    }

弱引用

// 无论内存是否足够,只要JVN开始回收,弱引用都会被回收
很多文章都说,只要执行GC就会回收软引用,这种结论是错误的。

当一个对象只被弱引用实例引用(持有)时,这个对象就会被GC回收

  • 被回收的对象弱引用实例引用的对象,而不是弱引用本身
  • 如果显式地声明了一个变量E e,并使之指向一个对象:e = new E(),这时变量e就是对对象的一个强引用。如果变量e所引用的这个对象同时又被WeakReference的一个实例持有,则由于存在对对象的一个强引用e,对象并不符合上述回收规则,因此对象至少在变量e的作用域范围内都不会被回收。
class TestWeakReference {
    private static List list = new ArrayList<>();
    public static void main(String[] args) {
        testWeakReference();
    }
    private static void testWeakReference() {
        byte[]buff = new byte[1024 * 1024];
        for (int i = 0; i < 10; i++) {
            WeakReference weakReference = new WeakReference<>(buff);
            list.add(weakReference);
        }
        System.gc();

        for (int i =0; i < list.size(); i ++) {
            Object o = ((WeakReference)list.get(i)).get();
            System.out.println(o);
        }
    }
}

在上述情况下,buff是一个强引用类型,在它的作用域时是不可回收的,即使除了弱引用持有没有其他的引用。

将上述代码改一下,将buff与gc作用域修改

class TestSoftReference {
    private static List list = new ArrayList<>();
    private static List lists = new ArrayList<>();
    public static void main(String[] args) {

        testWeakReference();
        gc();
    }
    static WeakReference softReference;
    private static void testWeakReference() {
        byte[]buff = new byte[1024 * 1024];
        for (int i = 0; i < 10; i++) {
            softReference = new WeakReference<>(buff);
            list.add(softReference);
        }
    }
    public static void gc() {
        System.gc();

        for (int i =0; i < list.size(); i ++) {
            Object o = ((WeakReference)list.get(i)).get();
            System.out.println(o);
        }
    }
}

在上面这种情况下,gc执行的作用域与buff的作用域是同级的另一个作用域,且buff无其他引用,则可以回收

将上述代码再修改一下

class TestWeakReference {
    private static List list = new ArrayList<>();
    public static void main(String[] args) {
        testWeakReference();
    }
    private static void testWeakReference() {
        for (int i = 0; i < 10; i++) {
            byte[]buff = new byte[1024 * 1024];
            WeakReference weakReference = new WeakReference<>(buff);
            list.add(weakReference);
        }
        System.gc();

        for (int i =0; i < list.size(); i ++) {
            Object o = ((WeakReference)list.get(i)).get();
            System.out.println(o);
        }
    }
}


此时buff的作用域只在for循环内,此时是可以被回收的,因为输出的结果均为null

虚引用

虚引用是最弱的引用类型,如果一个对象仅持有虚引用,那么它就和没有任何引用一样,它随时可能会被回收。
永远无法通过虚引用来获取对象,虚引用必须要和 ReferenceQueue 引用队列一起使用。

引用队列(ReferenceQueue)

引用队列可以与软引用、弱引用以及虚引用一起配合使用,当垃圾回收器准备回收一个对象时,如果发现它还有引用,那么就会在回收对象之前,把这个引用加入到与之关联的引用队列中去。程序可以通过判断引用队列中是否已经加入了引用,来判断被引用的对象是否将要被垃圾回收,这样就可以在对象被回收之前采取一些必要的措施。

与软引用、弱引用不同,虚引用必须和引用队列一起使用。

你可能感兴趣的:(java 强、软、弱、虚引用类型)