Java中存在四种引用，分别为强引用(Strong Reference)、软引用(Soft Refefence)、弱引用(Weak Refefence)和虚引用(Phantom Refefence)，这四种引用的强度依次减弱。
一、强引用
强引用就是指在程序代码中普遍存在的，类似Object obj = new Object()这类的引用，只要强引用还存在，垃圾收集器永远不会回收掉被引用的对象。如果没有足够的内存，就会抛出内存溢出异常。
public class StrongReferenceTest {
private static final int MEGA_BYTE = 1024 * 1024;
/**
* -Xms10M -Xmx10M -Xmn5M
*/
public static void main(String[] args) {
byte[] tenMegaByte1 = new byte[MEGA_BYTE * 2];
byte[] tenMegaByte2 = new byte[MEGA_BYTE * 2];
byte[] tenMegaByte3 = new byte[MEGA_BYTE * 2];
byte[] tenMegaByte4 = new byte[MEGA_BYTE * 2];
byte[] tenMegaByte5 = new byte[MEGA_BYTE * 2];
}
}
如上代码所示，最大堆空间为10M，然后创建五个每个大小都为2M的大对象，GC回收的时候发现这五个对象都是强引用，没法回收内存，抛出OutOfMemoryError。运行结果如下：
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
at top.liaohuaida.reference.StrongReferenceTest.main(StrongReferenceTest.java:17)
二、软引用
Java中提供了SoftReference类来实现软引用。软引用是用来描述一些还有用但并非必需的对象。对于软引用的关联着的对象，在系统将要发生内存溢出异常之前，将会把这些对象列进回收范围之中进行第二次回收。如果这次回收还没有足够的内存，才会抛出内存溢出异常。
public class SoftReferenceTest {
private static final int MEGA_BYTE = 1024 * 1024;
/**
* -Xms10M -Xmx10M -Xmn5M
*/
public static void main(String[] args) {
SoftReference<byte[]> softReference1 = new SoftReference<byte[]>(new byte[MEGA_BYTE * 2]);
System.gc();
System.out.println("第一次GC后SoftReference的值：" + softReference1.get());
SoftReference<byte[]> softReference2 = new SoftReference<byte[]>(new byte[MEGA_BYTE * 2]);
System.gc();
System.out.println("第二次GC后SoftReference的值：" + softReference1.get());
SoftReference<byte[]> softReference3 = new SoftReference<byte[]>(new byte[MEGA_BYTE * 2]);
System.gc();
System.out.println("第三次GC后SoftReference的值：" + softReference1.get());
SoftReference<byte[]> softReference4 = new SoftReference<byte[]>(new byte[MEGA_BYTE * 2]);
System.gc();
System.out.println("第四次GC后SoftReference的值：" + softReference1.get());
System.gc();
SoftReference<byte[]> softReference5 = new SoftReference<byte[]>(new byte[MEGA_BYTE * 2]);
System.out.println("第五次GC后SoftReference的值：" + softReference1.get());
}
}
如上代码所示，每次创建一个2M的对象之后，就显示调用一次System.gc()来回收内存，结果如下所示，前四次回收并没有回收掉softReference1关联对象的内存。但是第五次回收的时候，内存不足，将要发生内存溢出，此时softReference1关联对象的内存被回收，其实其他SoftReference关联对象的内存也都被回收掉了。
第一次GC后SoftReference的值：[B@6d13722b
第二次GC后SoftReference的值：[B@6d13722b
第三次GC后SoftReference的值：[B@6d13722b
第四次GC后SoftReference的值：[B@6d13722b
第五次GC后SoftReference的值：null
三、弱引用
Java提供了WeakReference类来实现弱引用。弱引用也是用来描述非必要对象的，但是它的强度比软引用更弱一些，被弱引用关联的对象只能生存到下一次垃圾收集发生之前。当垃圾收集器工作时，无论当前内存是否足够，都会回收掉只被弱引用关联的对象。
public class WeakReferenceTest {
private static final int MEGA_BYTE = 1024 * 1024;
/**
* -Xms10M -Xmx10M -Xmn5M
*/
public static void main(String[] args) {
WeakReference<byte[]> weakReference1 = new WeakReference<byte[]>(new byte[MEGA_BYTE * 2]);
System.out.println("第一次GC前weakReference1的值：" + weakReference1.get());
System.gc();
System.out.println("第一次GC后weakReference1的值：" + weakReference1.get());
WeakReference<byte[]> weakReference2 = new WeakReference<byte[]>(new byte[MEGA_BYTE * 2]);
System.out.println("第二次GC前weakReference2的值：" + weakReference2.get());
System.gc();
System.out.println("第二次GC后weakReference2的值：" + weakReference2.get());
// WeakReference<byte[]> weakReference3 = new WeakReference<byte[]>(new byte[MEGA_BYTE * 2]);
// System.gc();
// System.out.println("第三次GC后weakReference3的值：" + weakReference3.get());
// WeakReference<byte[]> weakReference4 = new WeakReference<byte[]>(new byte[MEGA_BYTE * 2]);
// System.gc();
// System.out.println("第四次GC后weakReference4的值：" + weakReference4.get());
// System.gc();
// WeakReference<byte[]> weakReference5 = new WeakReference<byte[]>(new byte[MEGA_BYTE * 2]);
// System.out.println("第五次GC后weakReference5的值：" + weakReference5.get());
}
}
如上代码所示，每次创建一个2M的对象之后，就显示调用一次System.gc()来回收内存，结果如下所示，每次回收内存都会回收掉WeakReference关联对象的内存，而不管内存是否充足。注释掉的部分结果也是相同的。
第一次GC前weakReference1的值：[B@21a437b6
第一次GC后weakReference1的值：null
第二次GC前weakReference2的值：[B@8939ec3
第二次GC后weakReference2的值：null
四、虚引用
Java提供PhantomReference类来实现虚引用。虚引用也被称为幽灵引用或者幻影引用，它是一种最弱的引用关系。一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来取得一个对象实例。在一个对象设置虚引用关联的唯一目的就是能在这个对象被垃圾收集回收时收到一个系统通知。
