WeakReference & SoftReference & WeakHashMap

Reference

java.lang.ref包下面，继承于Reference类，帮助gc识别对象引用如何处理

FinalReference: 强引用，即 Object obj = new Object(); 不会被强制回收，会引起OutOfMemory异常
WeakReference，每次gc都会被回收，不会引起OOM
SoftReference，只有内存不够用时，才会被gc回收，不会引起OOM
PhantomReference，不会被回收，会引起OOM，类似强引用。作用是在回收前，放入指定的ReferenceQueue，帮助跟踪

回收后，reference.get()会返回null指针

public class Test {

	private static AtomicInteger finalC = new AtomicInteger();
	public static class Bean {
		private byte[] bs = new byte[1024];
		public Bean() {
			byte b = 1;
			Arrays.fill(bs, b);
		}
		@Override
		protected void finalize() throws Throwable { 
			finalC.incrementAndGet();
		}
	}
	
	private ReferenceQueue<Bean> queue = new ReferenceQueue<Bean>();
	
	private void log(String phase) throws Exception {
		Field f = queue.getClass().getDeclaredField("queueLength");
		f.setAccessible(true);
		System.out.println(phase + "~~~, queue length:" + f.get(queue) + ", final num:" + finalC);
	}
	
	public void test() throws Exception {
		
		log("before");
		List<Reference> refs = new ArrayList<Reference>();
		for(int i = 0; i < 20480; ++i) {
			refs.add(new WeakReference<Test.Bean>(new Bean(), queue));
//			refs.add(new SoftReference<Test.Bean>(new Bean(), queue));
//			refs.add(new PhantomReference<Test.Bean>(new Bean(), queue));
			if(i % 3000 == 0) {
				int nullC = 0;
				for(int j = 0; j < i; ++j) {
					if(refs.get(j).get() == null) ++nullC;
				}
				log("number:" + i + ", null:" + nullC);
			}
		}
		log("2");
		System.gc();
		log("3");
		System.runFinalization();
		log("4");
	}
}

上述程序，跑在-Xmx=10m下，每个Bean > 1k，循环跑 2048个，大于 20M

====== WeakReference

before~~~, queue length:0, final num:0
number:0, null:0~~~, queue length:0, final num:0
number:6000, null:4746~~~, queue length:4746, final num:4230
number:12000, null:9688~~~, queue length:9688, final num:9688
number:18000, null:17130~~~, queue length:15985, final num:15853
2~~~, queue length:17419, final num:18006
3~~~, queue length:17723, final num:18119
4~~~, queue length:19539, final num:20480

在6000个时，内存还未满，此时回收队列中已有4746个item已标识为NULL，并且4230个已经被finanlized

===== SoftReference

before~~~, queue length:0, final num:0
number:0, null:0~~~, queue length:0, final num:0
number:6000, null:0~~~, queue length:0, final num:0
number:12000, null:9197~~~, queue length:9197, final num:9197
number:18000, null:17722~~~, queue length:17722, final num:17722
2~~~, queue length:17722, final num:17722
3~~~, queue length:17722, final num:17722
4~~~, queue length:17722, final num:20480

在6000个时，内存未满，jvm不会强制回收SoftReference，直到12000已经超出内存xmx时

====== phantomReference

before~~~, queue length:0, final num:0
number:0, null:0~~~, queue length:0, final num:0
number:6000, null:6000~~~, queue length:0, final num:3294
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space

不会被强制回收，于是OOM

WeakHashMap

包含一个类对象成员： private final ReferenceQueue<K> queue = new ReferenceQueue<K>(); （构建Reference可以不指定队列，但map利用被回收ref放入队列的特性，做了特殊处理）

使用WeakHashMap.Entry extends WeakReference 构建entry： tab[i] = new Entry<K,V>(k, value, queue, h, e);

Entry即是一个弱指针，弱指向key对象。即weakReference.get() = key。每次gc的时候，weakReference指向的entry.key为被回收置为空，并且entry将被放入referenceQueue。注意，此时map中的entry对象本事不为空，value不会空，只有key为空。所以直接获取entry是要出NPE的。

为此，每次获取entry时，需要通过ReferenceQueue清理table中key为null的entry：

private void expungeStaleEntries() {
	Entry<K,V> e;
        while ( (e = (Entry<K,V>) queue.poll()) != null) {
            // 将选定被回收的item，从hashmap集合中置空，跳过。防止hashmap返回null entry
        }
    }

同上面的例子，bean > 1K, 运行在 -Xmx10m下

private Map<String, Bean> map;
	
	public void test() throws Exception {
		map = new HashMap<String, Test.Bean>();
//		map = new WeakHashMap<String, Test.Bean>();
		
		for(int i = 1; i < 10240; ++i) {
			map.put(String.valueOf(i), new Bean());
			if(i%1000 == 0) {
				int size = 0;
				int npsize = 0;
				for(Entry<String, Test.Bean> entry : map.entrySet()) {
					++size;
					if(entry.getKey() == null || entry.getValue() == null) {
						npsize++;
					}
				}
				System.out.println("num: " + i + ", map size:" + size + ", null pointer:" + npsize);
			}
		}
	}

=============== HashMap

num: 1000, map size:1000, null pointer:0
num: 2000, map size:2000, null pointer:0
......
num: 8000, map size:8000, null pointer:0
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space

=============== WeakHashMap

num: 1000, map size:1000, null pointer:0
num: 2000, map size:2000, null pointer:0
num: 3000, map size:872, null pointer:0
num: 4000, map size:1872, null pointer:0
num: 5000, map size:604, null pointer:0
num: 6000, map size:1604, null pointer:0
num: 7000, map size:99, null pointer:0
num: 8000, map size:1099, null pointer:0
num: 9000, map size:123, null pointer:0
num: 10000, map size:1123, null pointer:0

可见，随着内存增加，entry被不停的会收，并且直接在map中被删除，不会留下空指针