Java四种引用类型
引用与对象
每种编程语言都有本身操做内存中元素的方式，例如在 C 和 C++ 里是经过指针，而在 Java 中则是经过“引用”。
在 Java 中一切都被视为了对象，可是咱们操做的标识符其实是对象的一个引用（reference）。java
//建立一个引用，引用能够独立存在，并不必定须要与一个对象关联 String s;
经过将这个叫“引用”的标识符指向某个对象，以后即可以经过这个引用来实现操做对象了。算法
String str = new String("abc");
System.out.println(str.toString());
在 JDK1.2 以前，Java中的定义很传统：若是 reference 类型的数据中存储的数值表明的是另一块内存的起始地址，就称为这块内存表明着一个引用。
Java 中的垃圾回收机制在判断是否回收某个对象的时候，都须要依据“引用”这个概念。
在不一样垃圾回收算法中，对引用的判断方式有所不一样：编程
- 引用计数法：为每一个对象添加一个引用计数器，每当有一个引用指向它时，计数器就加1，当引用失效时，计数器就减1，当计数器为0时，则认为该对象能够被回收（目前在Java中已经弃用这种方式了）。
- 可达性分析算法：从一个被称为 GC Roots 的对象开始向下搜索，若是一个对象到GC Roots没有任何引用链相连时，则说明此对象不可用。
JDK1.2 以前，一个对象只有“已被引用”和"未被引用"两种状态，这将没法描述某些特殊状况下的对象，好比，当内存充足时须要保留，而内存紧张时才须要被抛弃的一类对象。数组
四种引用类型
因此在 JDK.1.2 以后，Java 对引用的概念进行了扩充，将引用分为了：强引用（Strong Reference）、软引用（Soft Reference）、弱引用（Weak Reference）、虚引用（Phantom Reference）4 种，这 4 种引用的强度依次减弱。缓存
一，强引用
Java中默认声明的就是强引用，好比：编程语言
Object obj = new Object(); //只要obj还指向Object对象，Object对象就不会被回收 obj = null; //手动置null
只要强引用存在，垃圾回收器将永远不会回收被引用的对象，哪怕内存不足时，JVM也会直接抛出OutOfMemoryError，不会去回收。若是想中断强引用与对象之间的联系，能够显示的将强引用赋值为null，这样一来，JVM就能够适时的回收对象了函数
二，软引用
软引用是用来描述一些非必需但仍有用的对象。在内存足够的时候，软引用对象不会被回收，只有在内存不足时，系统则会回收软引用对象，若是回收了软引用对象以后仍然没有足够的内存，才会抛出内存溢出异常。这种特性经常被用来实现缓存技术，好比网页缓存，图片缓存等。
在 JDK1.2 以后，用java.lang.ref.SoftReference类来表示软引用。测试
下面以一个例子来进一步说明强引用和软引用的区别：
在运行下面的Java代码以前，须要先配置参数 -Xms2M -Xmx3M，将 JVM 的初始内存设为2M，最大可用内存为 3M。优化
首先先来测试一下强引用，在限制了 JVM 内存的前提下，下面的代码运行正常this
public class TestOOM {
public static void main(String[] args) {
testStrongReference();
}
private static void testStrongReference() {
// 当 new byte为 1M 时，程序运行正常
byte[] buff = new byte[1024 * 1024 * 1];
}
}
可是若是咱们将
byte[] buff = new byte[1024 * 1024 * 1];
替换为建立一个大小为 2M 的字节数组
byte[] buff = new byte[1024 * 1024 * 2];
则内存不够使用，程序直接报错，强引用并不会被回收
接着来看一下软引用会有什么不同，在下面的示例中连续建立了 10 个大小为 1M 的字节数组，并赋值给了软引用，而后循环遍历将这些对象打印出来。
public class TestOOM {
private static List<Object> list = new ArrayList<>();
public static void main(String[] args) {
testSoftReference();
}
private static void testSoftReference() {
for (int i = 0; i < 10; i++) {
byte[] buff = new byte[1024 * 1024];
SoftReference<byte[]> 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);
}
}
}
打印结果：
咱们发现不管循环建立多少个软引用对象，打印结果老是只有最后一个对象被保留，其余的obj全都被置空回收了。
这里就说明了在内存不足的状况下，软引用将会被自动回收。
值得注意的一点 , 即便有 byte[] buff 引用指向对象, 且 buff 是一个strong reference, 可是 SoftReference sr 指向的对象仍然被回收了，这是由于Java的编译器发现了在以后的代码中, buff 已经没有被使用了, 因此自动进行了优化。
若是咱们将上面示例稍微修改一下：
private static void testSoftReference() {
byte[] buff = null;
for (int i = 0; i < 10; i++) {
buff = new byte[1024 * 1024];
SoftReference<byte[]> 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);
}
System.out.println("buff: " + buff.toString());
}
则 buff 会由于强引用的存在，而没法被垃圾回收，从而抛出OOM的错误。
若是一个对象唯一剩下的引用是软引用，那么该对象是软可及的（softly reachable）。垃圾收集器并不像其收集弱可及的对象同样尽可能地收集软可及的对象，相反，它只在真正 “须要” 内存时才收集软可及的对象。
三，弱引用
弱引用的引用强度比软引用要更弱一些，不管内存是否足够，只要 JVM 开始进行垃圾回收，那些被弱引用关联的对象都会被回收。在 JDK1.2 以后，用 java.lang.ref.WeakReference 来表示弱引用。
咱们以与软引用一样的方式来测试一下弱引用：
private static void testWeakReference() {
for (int i = 0; i < 10; i++) {
byte[] buff = new byte[1024 * 1024];
WeakReference<byte[]> sr = new WeakReference<>(buff);
list.add(sr);
}
System.gc(); //主动通知垃圾回收
for(int i=0; i < list.size(); i++){
Object obj = ((WeakReference) list.get(i)).get();
System.out.println(obj);
}
}
打印结果：
能够发现全部被弱引用关联的对象都被垃圾回收了。
四，虚引用
虚引用是最弱的一种引用关系，若是一个对象仅持有虚引用，那么它就和没有任何引用同样，它随时可能会被回收，在 JDK1.2 以后，用 PhantomReference 类来表示，经过查看这个类的源码，发现它只有一个构造函数和一个 get() 方法，并且它的 get() 方法仅仅是返回一个null，也就是说将永远没法经过虚引用来获取对象，虚引用必需要和 ReferenceQueue 引用队列一块儿使用。
public class PhantomReference<T> extends Reference<T> {
/**
* Returns this reference object's referent. Because the referent of a
* phantom reference is always inaccessible, this method always returns
* <code>null</code>.
*
* @return <code>null</code>
*/
public T get() {
return null;
}
public PhantomReference(T referent, ReferenceQueue<? super T> q) {
super(referent, q);
}
}
那么传入它的构造方法中的 ReferenceQueue 又是如何使用的呢？
五，引用队列（ReferenceQueue）
引用队列能够与软引用、弱引用以及虚引用一块儿配合使用，当垃圾回收器准备回收一个对象时，若是发现它还有引用，那么就会在回收对象以前，把这个引用加入到与之关联的引用队列中去。程序能够经过判断引用队列中是否已经加入了引用，来判断被引用的对象是否将要被垃圾回收，这样就能够在对象被回收以前采起一些必要的措施。
与软引用、弱引用不一样，虚引用必须和引用队列一块儿使用。