Java中的引用--强软弱虚
强引用
Object object = new Object()，这个object就是一个强引用。如果一个对象具有强引用，那就类似于必不可少的生活用品，垃圾回收器绝不会回收它。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError异常，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题。
软引用(SoftReference)
如果一个对象只具有软引用，那就类似于可有可物的生活用品。如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。 软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。
public class TestSoftReference {
public static void main(String[] args) throws InterruptedException {
ReferenceQueue<Object> queue = new ReferenceQueue<>();
// m强引用指向softReference,softReference软指向byte[]
SoftReference<byte[]> m = new SoftReference<>(new byte[1024 * 1024 * 10],queue);
// 打印结果:[B@1e643faf
System.out.println(m.get());
System.gc();
Thread.sleep(1000);
// 打印结果:[B@1e643faf 表示没有被垃圾回收
System.out.println(m.get());
// 给出一个强引用
byte[] bytes = new byte[1024 * 1024 * 15];
// 不规定最大堆内存大小时，打印结果:[B@1e643faf
// 指定最大堆内存-Xmx20M时，打印输出null
System.out.println(m.get());
//打印结果:java.lang.ref.SoftReference@6e8dacdf
System.out.println(queue.poll());
}
}
不指定参数，输出结果
[B@1e643faf
[B@1e643faf
[B@1e643faf
null
指定参数-Xmx20M，输出结果
[B@1e643faf
[B@1e643faf
null
java.lang.ref.SoftReference@6e8dacdf
弱引用(WeakReference)
如果一个对象只具有弱引用，那就类似于可有可物的生活用品。弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它 所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程， 因此不一定会很快发现那些只具有弱引用的对象。 弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。
public class TestWeakReference {
public static void main(String[] args) {
WeakReference<byte[]> m = new WeakReference<>(new byte[1024*1024*10]);
System.out.println(m.get());
System.gc();
System.out.println(m.get());
}
}
有垃圾回收直接回收，打印结果：
[B@1e643faf
null
虚引用(PhantomReference)
顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。 虚引用主要用来跟踪对象被垃圾回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。 主要用在管理对外内存
ThreadLocal
ThreadLocal提供线程局部变量。这些变量与普通变量不同，因为每个线程都有其自己的、独立初始化的变量副本。ThreadLocal实例通常是类中的私有静态变量，并将它与线程的状态绑定（例如，用户ID或事务ID）。
简单案例：
public class TestThreadLocal {
private static final AtomicInteger nextId = new AtomicInteger(0);
private static final ThreadLocal<Integer> threadId = ThreadLocal.withInitial(nextId::getAndIncrement);
public static int get() {
return threadId.get();
}
public static void main(String[] args) {
new Thread(()->{
System.out.println(TestThreadLocal.get()); // 0
try {
Thread.sleep(1000);
System.out.println(TestThreadLocal.get()); // 0
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
new Thread(()->{System.out.println(TestThreadLocal.get());}).start(); // 1
}
}
这里通过ThreadLocal对象threadId为每一个调用TestThreadLocal.get()方法的线程赋予一个线程Id，第4行通过ThreadLocal.withInitial(nextId::getAndIncrement)得到ThreadLocal的子类SuppliedThreadLocal对象，SuppliedThreadLocal对象复写了initialValue方法。
@Override
protected T initialValue() {
return supplier.get();
}
具体细节下面再谈。先看看main方法，其中启动了两个线程，可以看到每个线程通过调用TestThreadLocal.get()得到独有的Id。接下来分析ThreadLocal的主要方法。
set方法
源代码：
public void set(T value) {
// 获取当前线程
Thread t = Thread.currentThread();
// 得到线程的threadLocals属性，是ThreadLocalMap对象,其中k为这个ThreadLocal对象，v为value
ThreadLocalMap map = getMap(t);
if (map != null) {
map.set(this, value);
} else {
createMap(t, value);
}
}
从中可以看到ThreadLocalMap对象是实现功能的关键，整体思路和HashMap相似，具体代码就不细看了，有兴趣可以自己点进去看，接下来只讲述其中的关键点。ThreadLocalMap维护了一个Entry数组，对ThreadLocal对象的HashCode进行处理后作为index将Entry对象添加到数组中。接下来就是重中之重，Entry类：
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
可以看到Entry类继承了 WeakReference，他的弱引用指向了ThreadLocal对象，并且拥有属性value。看下来可能有点晕了，给出一个图方便理解
可以理解为每一个Thread都有一个ThreadLocalMap属性，其中key为弱引用指向ThreadLocal,value为强引用指向传入的对象。
为什么要用弱引用作为key？
如果key为强引用,当我们现在将ThreadLocal的引用指向为null，但是每个线程中有自己独立ThreadLocalMap，还会一直持有该对象，所以ThreadLocal对象不会被回收，会发生内存泄漏问题。如果key为弱引用，当我们现在将ThreadLocal的引用指向为null时，线程中独立的ThreadLocalMap中的ThreadLocal对象会被回收。
还是有内存泄漏？
但是会发现就算是key被回收了，value也仍然被Entry中的value强引用指着不会被回收，依然会发生内存泄漏，所以在不用value的时候应该主动调用ThreadLocal对象的remove方法来移除。
remove方法
源代码：
private void remove(ThreadLocal<?> key) {
Entry[] tab = table;
int len = tab.length;
int i = key.threadLocalHashCode & (len-1);
for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {
if (e.get() == key) {
e.clear(); // 清理弱引用
expungeStaleEntry(i);
return;
}
}
}
expungeStaleEntry(i);将Entry数组的第i个entry对象的value置为null，然后将这个enrty对象置为null，最后进行rehash。
get方法
源代码：
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}
在get方法中，通过getMap()获得当前Thread对象的threadLocals属性。在没有调用set方法之前，threadLocals属性为null，所以会调用setInitialValue()：
private T setInitialValue() {
T value = initialValue();
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
map.set(this, value);
} else {
createMap(t, value);
}
if (this instanceof TerminatingThreadLocal) {
TerminatingThreadLocal.register((TerminatingThreadLocal<?>) this);
}
return value;
}
可以看到，直接调用initialValue()方法得到value，然后设置并返回value，这就是前面为什么重写initialValue()方法。通过重写initialValue()方法，给顶一个初始值，这样在没有调用set方法之前调用get方法就会从initialValue()中得到一个初始值。