Java四种引用--《深入理解Java虚拟机》学习笔记及个人理解(四)

Java四种引用--《深入理解Java虚拟机》学习笔记及个人理解(四)

书上P65.

StrongReference(强引用)

类似Object obj = new Object() 这类的引用 就是强引用.

SoftReference(软引用)

用来描述一些有用但并非必需的对象. 在系统将要发生内存溢出异常前, 将会把这些对象列进回收范围之中, 进行二次回收.(如果这次回收了之后, 内存还是不足, 那么就会抛出内存溢出异常)

执行下面这段代码的时候, 设置一下虚拟机参数-Xms2m -Xmx2m. 设置最大堆内存. 不然程序要运行很久才能堆内存溢出....

import java.lang.ref.SoftReference;
import java.util.ArrayList;
import java.util.List;

/**
 * VM Options: -Xms2m -Xmx2m
 */
public class Main {
    public static void main(String[] args) {
        Dog<String> dog = new Dog<>(new String("1234321"));
        System.out.println("内存溢出之前: " + dog.get()); // 1234321

        try {
            for (List<Object> arrayList = new ArrayList<>(); ; )
                arrayList.add(new Object());
        } catch (Throwable e) {
            System.out.println("内存溢出时:" + dog.get()); // null
        }
    }

    static class Dog<V> extends SoftReference<Object> {
        public Dog(V value) {
            super(value);
        }
    }
}

输出结果如下:

WeakReference(弱引用)

弱引用也是用来描述非必需对象的, 强度比软引用还要弱. 被弱引用关联的对象只能生存到下一次垃圾收集器发生之前. 当垃圾收集器工作时, 无论当前内存是否足够, 都会被回收掉. (这里指的是"只有弱引用"的情况, 如果同时还被其他强引用关联了, GC Root可达, 那么当然不会被回收了.)

import java.lang.ref.WeakReference;

public class Main {
    public static void main(String[] args) {
        Integer a = new Integer(111);
        String b = new String("222");
        Node wrc = new Node(a, b);
        System.out.println("gc之前: " + wrc.get());
        System.out.println(wrc.value);
        a = null;
        System.gc();
        System.out.println("gc之后: " + wrc.get());
        System.out.println(wrc.value);

    }
}

class Node<K, V> extends WeakReference<Object> {
    V value;

    public Node(K key, V value) {
        super(key);
        this.value = value;
    }
}

PhantomReference(虚引用, 幽灵引用, 幻影引用)

这是最弱的引用. 这个不会影响到对象的生存时间. 也无法通过ge()来获取到对象实例(永远是null).

不过可以用虚引用让一个对象被收集器回收时执行一段通知.

本段例子来自于https://www.baeldung.com/java-phantom-reference

/**
 * https://www.baeldung.com/java-phantom-reference
 */
public class PhantomReferenceTest {
    public static void main(String[] args) {
        ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();
        List<LargeObjectFinalizer> references = new ArrayList<>();
        List<Object> largeObjects = new ArrayList<>();

        for (int i = 0; i < 3; ++i) {
            Object largeObject = new Object();
            largeObjects.add(largeObject);
            references.add(new LargeObjectFinalizer(largeObject, referenceQueue));
        }

        for (PhantomReference<Object> reference : references) {
            System.out.println(reference.isEnqueued());
        }

        largeObjects = null;
        System.gc();

        for (PhantomReference<Object> reference : references) {
            System.out.println(reference.isEnqueued());
        }

        for (Reference<?> referenceFromQueue; (referenceFromQueue = referenceQueue.poll()) != null; referenceFromQueue.clear()) {
            ((LargeObjectFinalizer) referenceFromQueue).finalizeResources();
        }
    }

    static class LargeObjectFinalizer extends PhantomReference<Object> {

        LargeObjectFinalizer(Object referent, ReferenceQueue<? super Object> q) {
            super(referent, q);
        }

        void finalizeResources() {
            System.out.println("clearing ...");
        }
    }
}

输出结果如下: