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 ...");
}
}
}
输出结果如下: