引言
Java虚拟机会为我们管理内存，当内存不足时，通过垃圾回收算法来释放不可达的内存。作为Java程序员我们似乎不需要关注这些。
但是在工作中我们可能会遇到内存充足的情况下，也会出现OutOfMemoryError。
笔者就多次遇到过这种情况，有一次是加载内容过多引起的，通过Xmx2g，在分配了2G内存的情况下出现了内存溢出的问题，最后定位到了是压测的时候压测导出Excel接口没有分页导致一次性读取整张表的数据到内存，同时查询数据量过多时间过长，上一个还没导出成功下一个导出请求又来了。
解决方案是控制一次导出的数据量。在此期间执行过Full GC，但是并不会回收加载到内存中的待导出数据，因为它们都是强引用。
本文的切入点是引用类型，下面开始进入主题。Java中有四种引用类型：强引用(Strong Reference)，软引用(Soft Reference)，弱引用(Weak Reference)和虚引用(Phantom Reference)。
强度由强到弱。
软引用和弱引用哪个更强呢？是不是容易混淆。可以通过单词来记忆，Strong的反义词是Weak,Strong很强的话，Weak就很弱了，而Soft就介于它们之间。
强引用
我们通常遇到的引用类型都是强引用，比如通过new关键词实例化的对象：
Object obj = new Object();
如果没有出现obj = null，那么在它的作用域范围内，GC是不会进行回收的。当然可能你知道这个对象已经没用了，但是GC不知道。
因此很多书籍推荐显示的执行obj = null将该引用置空，这样它原先的那块内存就是不可达的了。
软引用
为了演示软引用，我们定义一个类，复写了它的finalize方法，打印一些日志，以使我们知悉。
public class MyObject {
@Override
protected void finalize() throws Throwable {
super.finalize();
System.out.println("MyObject's finalize called.");
}
@Override
public String toString() {
return "MyObject@" + Integer.toHexString(hashCode());
}
}构造软引用代码如下：
MyObject obj = new MyObject();//强引用
ReferenceQueue<MyObject> softQueue = new ReferenceQueue<>();//创建引用队列,如果对象被回收则进入引用队列
SoftReference<MyObject> softRef = new SoftReference<>(obj,softQueue);//创建软引用
new CheckRefQueueThread(softQueue).start();
obj = null;//删除强引用
第1行构造了一个强引用对象，第3行构造了一个软引用对象。
也就是说，现在有两个引用指向了MyObject对象(obj和softRef中的referent，可以结合下图)。
注意软引用对象和软引用的对象之间的区别，软引用对象指该软引用本身，而软引用的对象指的是软引用中referent对象，也就是该软引用持有的对象，在本例中就是MyObject对象实例。下文中的弱引用的对象以及虚引用的对象都是这个意思。
上图中还有一个ReferenceQueue，这个后文会分析。
此时，MyObject实例还不具备被回收的条件(因为还有强引用指向它)。
第5行释放了该强引用，此时，该对象不存在强引用，但存在软引用（称为软可达(softly reachable )）。
此时，我们还是能使用MyObject对象，通过softRef.get()。
一个被软引用持有的对象不会被JVM很快回收，只有当堆快要溢出时（内存不足时），才会回收软引用的对象。也就是说，只要有足够的内存，软引用的对象就能在内存中存活相当长的一段时间，该对象还可以继续被程序使用。 软引用一般用来实现内存敏感的缓存。
下面给出完整的例子：
private static void testSoftReference() {
MyObject obj = new MyObject();//强引用
ReferenceQueue<MyObject> softQueue = new ReferenceQueue<>();//创建引用队列,如果对象被回收则进入引用队列
SoftReference<MyObject> softRef = new SoftReference<>(obj,softQueue);//创建软引用
new CheckRefQueueThread(softQueue).start();
obj = null;//删除强引用
System.gc();
System.out.println("After GC:soft Get=" + softRef.get());
System.out.println("分配大块内存");//分配大块内存，强迫GC
byte[] b = new byte[4 *1024 * 804];//防止出现OOM，这个值需要微调一下
System.out.println("After new byte[]:Soft Get=" + softRef.get());
}上面代码中的CheckRefQueueThread:
private static class CheckRefQueueThread extends Thread {
private ReferenceQueue<MyObject> queue;
private CheckRefQueueThread(ReferenceQueue<MyObject> queue) {
this.queue = queue;
}
@Override
public void run() {
Reference ref = null;
try {
ref = queue.remove();
} catch (InterruptedException e) {
e.printStackTrace();
}
if (ref != null) {
System.out.println("Object for " + ref.getClass().getSimpleName() + " is " + ref.get());
}
}
}执行前，先限定堆大小为5M: Xmx5M,执行结果为：
After GC:soft Get=MyObject@723279cf
分配大块内存
MyObject's finalize called.
Object for SoftReference is null
After new byte[]:Soft Get=null
(不同的电脑执行结果可能不同，需要微调byte[] b = new byte[4 *1024 * 804];里面的数值，过大的话会出现OOM)
我们来分析一下上面的执行结果，首先构造出MyObject对象，然后构造该对象的软引用softRef，并注册到引用队列，
当MyObject强引用对象被回收时，软引用会被加入到引用队列。
设置obj=null来删除强引用，此时MyObject对象变成软可达，然后显式调用GC，通过软引用的get()(此时我们只能通过软引用的该方法来访问它了，之前的obj已经置为null了)方法，还是可以取得MyObject对象实例的强引用，发现对象并未被回收。这说明GC在内存充足的情况下，并不会回收软可达对象。
然后请求一块大的堆空间，使得内存不足，从而迫使新一轮的GC。在这次GC后，软引用的get()方法也无法返回MyObject对象实例，说明，它已经被回收，此时该软引用会加入到注册的引用队列(通过构造函数注册)。
在新线程中将该软引用取出，同时调用get方法验证此时却是无法获取MyObject实例了。
弱引用
构造和测试弱引用的代码如下：
MyObject obj = new MyObject();
ReferenceQueue<MyObject> weakQueue = new ReferenceQueue<>();
WeakReference<MyObject> weakRef = new WeakReference<>(obj,weakQueue);
new CheckRefQueueThread(weakQueue).start();
obj = null;
System.out.println("Before GC:Weak Get=" + weakRef.get());
System.gc();
System.out.println("After GC:Weak Get=" + weakRef.get());
可以看出，和软引用的构造方法类似，只是名称不同。
第5行删除强引用，此时不存在强引用和软引用，存在弱引用指向它，称为弱可达(weakly reachable )。
在系统GC时，只要发现该对象仅是弱可达的，不管内存是否充足，都会对对象进行回收。但是，由于GC线程优先级较低，可能不会那么快的发现，可能也会存在较长时间。
上面代码的执行结果如下：
Before GC:Weak Get=MyObject@723279cf
MyObject's finalize called.
After GC:Weak Get=null
Object for WeakReference is null
从结果来看，在GC前，可以通过weakRef.get()取得对应的强引用。但是只要进行垃圾回收，并且发现弱引用的对象(这里是MyObject)是弱可达，便会立即被回收，并且weakRef会加入到引用队列中。
此时，再次通过get方法获取对象会失败。
弱引用的典型应用就是WeakHashMap，下面我们一起简单探讨下它的使用方法及原理。
WeakHashMap
它使用弱引用作为内部数据的存储方案。
Map<Integer,byte[]> map;
map = new WeakHashMap<>();//new HashMap<>();
for (int i = 0; i < 10000;i++) {
Integer ii = new Integer(i);//注意这个ii，它每次循环都指向一个Integer对象，下次循环后之前指向的对象就没有强引用指向它了，类似于ii = null;而在作用域之外，也是类似的
map.put(ii,new byte[i]);
}
使用-Xmx5M限定最大可用堆后，执行WeakHashMap的代码正常运行，使用HashMap的代码抛出java.lang.OutOfMemoryError: Java heap space。
WeakHashMap是如何工作的呢，在其源码中对Entry的定义如下：
/**
* 继承了WeakReference, 使用referent封装了key
*/
private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {
V value;
final int hash;
Entry<K,V> next;
/**
* Creates new entry.
*/
Entry(Object key, V value,
ReferenceQueue<Object> queue,
int hash, Entry<K,V> next) {
super(key, queue);//以key为referent构造了key的弱引用
this.value = value;
this.hash = hash;
this.next = next;
}
...
}
在上面的代码中似乎看不到K key了，其实它变成了WeakReference中的referent了，理解这一点很重要。
在WeakHashMap的各项操作中，如get()、put()函数，都直接或间接调用
了expungeStaleEntries()方法(方法名意味清理不新鲜的项)，以清理持有弱引用的key的表项。
private void expungeStaleEntries() {
//queue中都是弱可达对象的弱引用，表示这些对象可以移除了
//注意此处使用的是poll()方法，不会阻塞，如果队列中有值直接返回队顶元素；否则返回null
//若是remove()方法，在队列中无值的情况下会阻塞
for (Object x; (x = queue.poll()) != null; ) {
synchronized (queue) {
@SuppressWarnings("unchecked")
Entry<K,V> e = (Entry<K,V>) x;
int i = indexFor(e.hash, table.length);//找到这个项的索引
Entry<K,V> prev = table[i];
Entry<K,V> p = prev;
while (p != null) {
Entry<K,V> next = p.next;
if (p == e) {//找到了
if (prev == e)//说明是链表头节点
table[i] = next;
else
prev.next = next;//让pre指向它的next，就没有引用指向它了
// Must not null out e.next;
// stale entries may be in use by a HashIterator
e.value = null; // Help GC ,key已经不新鲜了，value也没什么用了
size--;
break;
}
prev = p;
p = next;
}
}
}
}简单了解下WeakHashMap的工作原理后，可以知道，如果存放WeakHashMap中的
key都存在强引用，那么WeakHashMap就会退化为HashMap：
Map<Integer, byte[]> map;
map = new WeakHashMap<>();//new HashMap<>();
List<Integer> list = Lists.newArrayList();
for (int i = 0; i < 10000; i++) {
Integer ii = new Integer(i);
list.add(ii);//强引用key
map.put(ii, new byte[i]);
}
上面的代码也会抛出内存不足异常。如果希望在系统中通过WeakHashMap自动清理数据，
就尽量不要在代码的其他地方强引用WeakHashMap的key，否则这些key就不会被回收。
虚引用
虚引用是所有引用中最弱的一个。它是finalize()方法的一个更加灵活的代替版本。
= new MyObject();
ReferenceQueue<MyObject> phantomQueue = new ReferenceQueue<>();
PhantomReference<MyObject> phantomRef = new PhantomReference<>(obj,phantomQueue);
System.out.println("Phantom Get: " + phantomRef.get());
new CheckRefQueueThread(phantomQueue).start();
obj = null;
Thread.sleep(1000);
int i = 1;
while (true) {
System.out.println("第" + i++ + "次gc");
System.gc();
Thread.sleep(1000);
}
本例中需要修改下检查引用线程的代码，在run()方法体最后加入：
ref.clear();//虚引用需要手动调用clear方法
System.exit(0);
软引用和弱引用其实可以在构造时将引用队列置为null，但是虚引用不同，没有注册引用队列的虚引用是没有意义的。
如果一个对象只存在虚引用指向它，那它就是虚可达(phantom reachable)。如果垃圾收集器发现虚引用的对象是虚可达的，
那么该虚引用对象会被加到引用队列。
上例中执行结果如下：
Phantom Get: null
第1次gc
MyObject's finalize called.
第2次gc
Object for PhantomReference is null
在虚引用中调用get()方法总是返回null，一个对象只有虚引用指向它，几乎和没有引用指向它是一样的。
在第一次GC时，系统找到了垃圾对象，并调用其finalize()方法回收内存，但是没有立即加入回收队列。第二次GC时，该对象真正被GC清除，此时，加入虚引用队列。
当JVM真正回收MyObject时，将虚引用放入引用队列。一旦从虚引用队列中取得该虚引用，表明虚引用的对象已经被回收。此时可以做一些清理工作，清理啥呢，清理GC无法清理的资源，比如文件句柄。
比如，在FileInputStream中重写了finalize方法：
protected void finalize() throws IOException {
if ((fd != null) && (fd != FileDescriptor.in)) {
close();
}
}最后会调用close()方法，所以如果你忘记调用的话，在GC回收FileInputStream对象时会很贴心的帮你关闭文件句柄，
但是如果一直没有GC的话，那么应该关闭的文件就会一直被打开，浪费系统资源。
虽然虚引用可以用于进行清理工作，但是一般情况下还是建议直接使用try-with-resource语法及时释放不要的资源。
