定义
弱引用是使用WeakReference创建的引用，弱引用也是用来描述非必需对象的，它是比软引用更弱的引用类型。在发生GC时，只要发现弱引用，不管系统堆空间是否足够，都会将对象进行回收。
说明
弱引用，从名字来看就很弱嘛，这种引用指向的对象，一旦在GC时被扫描到，就逃脱不了被回收的命运。
但是，弱引用指向的对象也并不一定就马上会被回收，如果弱引用对象较大，直接进到了老年代，那么就可以苟且偷生到Full GC触发前，所以弱引用对象也可能存在较长的一段时间。一旦一个弱引用对象被垃圾回收器回收，便会加入到一个引用队列中（如果有的话）。
弱引用对应的类为WeakReference，举个栗子：
String s = new String("Frank");
WeakReference<String> weakRef = new WeakReference<String>(s);
s = null;
复制
这里我们把s设置为null后，字符串对象便只有弱引用指向它。
弱可达
如果一个对象与GC Roots之间仅存在弱引用，则称这个对象为
弱可达(weakly reachable)
对象。
在垃圾回收器回收一个对象前，WeakReference类所提供的get方法会返回其引用对象的强引用，一旦垃圾回收器回收掉该对象之后，get方法将返回null。所以在获取弱引用对象的代码中，一定要判断是否为null，以免出现NullPointerException异常导致应用崩溃。
下面的代码会让s再次持有对象的强引用：
如果在weakRef包裹的对象被回收前，用强引用关联该对象，那这个对象又会变成强可达状态。
来看一个简单的栗子了解一下WeakReference引用的对象是何时被回收的：
public class WeakReferenceTest {
private static final List<Object> TEST_DATA = new LinkedList<>();
private static final ReferenceQueue<TestClass> QUEUE = new ReferenceQueue<>();
public static void main(String[] args) {
TestClass obj = new TestClass("Test");
WeakReference<TestClass> weakRef = new WeakReference<>(obj, QUEUE);
//可以重新获得OOMClass对象，并用一个强引用指向它
//oomObj = weakRef.get();
// 该线程不断读取这个弱引用，并不断往列表里插入数据，以促使系统早点进行GC
new Thread(() -> {
while (true) {
TEST_DATA.add(new byte[1024 * 100]);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
Thread.currentThread().interrupt();
System.out.println(weakRef.get());
}).start();
// 这个线程不断读取引用队列，当弱引用指向的对象呗回收时，该引用就会被加入到引用队列中
new Thread(() -> {
while (true) {
Reference<? extends TestClass> poll = QUEUE.poll();
if (poll != null) {
System.out.println("--- 弱引用对象被jvm回收了 ---- " + poll);
System.out.println("--- 回收对象 ---- " + poll.get());
}).start();
//将强引用指向空指针 那么此时只有一个弱引用指向TestClass对象
obj = null;
try {
Thread.currentThread().join();
} catch (InterruptedException e) {
e.printStackTrace();
System.exit(1);
static class TestClass {
private String name;
public TestClass(String name) {
this.name = name;
@Override
public String toString() {
return "TestClass - " + name;
}
复制
设置一下虚拟机参数：
-verbose:gc -Xms4m -Xmx4m -Xmn2m
复制
运行结果如下：
[GC (Allocation Failure) 1017K->464K(3584K), 0.0014345 secs]
[GC (Allocation Failure) 1483K->536K(3584K), 0.0017221 secs]
[GC (Allocation Failure) 1560K->648K(3584K), 0.0036572 secs]
TestClass - Test
TestClass - Test
TestClass - Test
[GC (Allocation Failure) 1621K->984K(3584K), 0.0011455 secs]
--- 弱引用对象被jvm回收了 ---- java.lang.ref.WeakReference@51a947fe
--- 回收对象 ---- null
...省略n个null和几次GC信息
[Full GC (Ergonomics) 2964K->2964K(3584K), 0.0025450 secs]
[Full GC (Allocation Failure) 2964K->2964K(3584K), 0.0021907 secs]
java.lang.OutOfMemoryError: Java heap space
Dumping heap to java_pid6860.hprof ...
Heap dump file created [3912229 bytes in 0.011 secs]
Exception in thread "Thread-0" java.lang.OutOfMemoryError: Java heap space
at weakhashmap.WeakReferenceTest.lambda$main$0(WeakReferenceTest.java:22)
at weakhashmap.WeakReferenceTest$$Lambda$1/764977973.run(Unknown Source)
at java.lang.Thread.run(Thread.java:748)
复制
可以看到，其实弱引用也并不是一发生GC就被回收掉了。
应用场景
如果一个对象仅仅是偶尔使用，并且希望在使用时随时就能获取到，但又不想影响此对象的垃圾收集，那么你应该用 WeakReference 来引用该对象。
弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。
一般来说，很少直接使用WeakReference，而是使用WeakHashMap。在WeakHashMap中，内部有一个引用队列，插入的元素会被包裹成WeakReference，并加入队列中，用来做缓存再合适不过。
在Tomcat的缓存中，其实就用到了WeakHashMap：
public final class ConcurrentCache<K,V> {
private final int size;
private final Map<K,V> eden;
private final Map<K,V> longterm;
public ConcurrentCache(int size) {
this.size = size;
this.eden = new ConcurrentHashMap<>(size);
this.longterm = new WeakHashMap<>(size);
public V get(K k) {
// 先从eden中取
V v = this.eden.get(k);
if (v == null) {
// 如果取不到再从longterm中取
synchronized (longterm) {
v = this.longterm.get(k);
// 如果取到则重新放到eden中
if (v != null) {
this.eden.put(k, v);
return v;
public void put(K k, V v) {
if (this.eden.size() >= size) {
// 如果eden中的元素数量大于指定容量，将所有元素放到longterm中
synchronized (longterm) {
this.longterm.putAll(this.eden);
this.eden.clear();
this.eden.put(k, v);
