Java中的引用类型（强引用、软引用、弱引用、虚引用）介绍，示例WeakHashMap的使用【享学Java】

末蓝、 2022-01-07 22:25 100阅读 0赞

#### 每篇一句 ####

> 头等舱可以优先登机，银行VIP不用排队，演唱会最贵的门票位置也最好。这个世界本来就不公平，你有多努力，你就有多特殊

#### 前言 ####

Java语言中的数据类型可划分为`值类型`和`引用类型`。从`JDK 1.2`版本开始，把对象的引用分为**4种级别**，从而使程序能**更加灵活地**控制对象的生命周期。  
这4种级别由**高到低依**次为：**强引用、软引用、弱引用和虚引用**。

#### 值类型和引用类型 ####

*  值类型：`byte、short、int、long、float、double、char、boolean`
 *  引用类型：除了值类型，所有的类型都是引用类型。（**数组、字符串、类、接口**等）

一个具有值类型的数据存放在栈内的一个变量中：栈内分配内存空间，**直接存储**所包含的值，**其值代表的数据本身**。  
而`引用类型`数据的**变量值会存放在堆中**，**变量名（引用地址）会存放在栈中**。

> 堆区: 1、存储的全部是对象，每个对象都包含一个与之对应的class的信息。(class的目的是得到操作指令) 2、jvm只有一个堆区(heap)被所有线程共享，**堆中不存放基本类型和对象引用，只存放对象本身**  
> 栈区：1、每个线程包含一个栈区，栈中只保存**基础数据类型（值就是本身）的对象和自定义对象的引用**(不是对象)，对象都存放在堆区中 2、每个栈中的数据(原始类型和对象引用)都是私有的，其他栈不能访问（所以也有人说栈是保存局部变量的）。 3、栈分为3个部分：基本类型变量区、执行环境上下文、操作指令区(存放操作指令)。  
> 方法区：又叫静态区。1、跟堆一样，**被所有的线程共享**。方法区包含所有的class和static变量。 2、方法区中包含的都是在整个程序中**永远唯一的元素，如class，static变量**。

**在Java7之前，HotSpot虚拟机中将GC分代收集扩展到了方法区，使用永久代来实现了方法区。这个区域的内存回收目标主要是针对常量池的回收和对类型的卸载。而在Java8中，已经彻底没有了永久代，将方法区直接放在一个与堆不相连的本地内存区域，这个区域被叫做元空间。**

栈里的数据，函数执行完就不会存储了。这就是为什么局部变量每一次都是一样的。就算给他加一后，下次执行函数的时候还是原来的样子。（**so，实例基本变量存在哪儿呢？所以：它显然不会是存在栈里的**）

> 栈里存储的变量都是瞬时的（方法执行完就死了），而堆里的对象靠垃圾回收（年轻代、永久代（元空间））

## Java引用类型 ##

在Java中提供了四个级别的引用：强引用，软引用，弱引用和虚引用。

// @since 1.2 所在包是：java.lang.ref
    public abstract class Reference<T> { 
    
    	// 构造函数是非public的 所以只能通包内的类才能访问此构造函数
        Reference(T referent) { 
            this(referent, null);
        }
        Reference(T referent, ReferenceQueue<? super T> queue) { 
            this.referent = referent;
            this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
        }
    	...
        public T get() { 
            return this.referent;
        }
        public void clear() { 
            this.referent = null;
        }
        public boolean isEnqueued() { 
            return (this.queue == ReferenceQueue.ENQUEUED);
        }
        public boolean enqueue() { 
            return this.queue.enqueue(this);
        }
    	...
    }

**直接子类**，只有下面这四个：  
![在这里插入图片描述][20190630114312940.png]  
`Reference<T>`是JDK1.2提供的引用类型，它有四个子类分别代表着四种引用类型。其中只有强引用`FinalReference`类是包内可见，其余的都是public的。这也侧面表示了：**强引用类型是Java默认的引用类型**，直接使用即可

> 其实`FinalReference`根本就不是强引用，网上很多文章都以讹传讹，问下我有勘误。

#### 强引用 ####

> 强引用（ Final Reference）：只要强引用还存在，垃圾收集器**永远不会**回收（JVM宁愿抛出OOM异常也不回收强引用所指向的对）被引用的对象。但是，强引用可能会造成**内存泄露**哦~

public class Main { 
    
        public static void main(String[] args) throws Exception { 
            Person person = new Person("fsx", 18);
            System.out.println(person); //强引用：直接使用
        }
    
    }

这就是强引用的典型示例，我们平时绝大多数情况下都使用强引用即可。

**强引用的特点：**

1.  可以**直接访问**目标对象。
2.  所指向的对象在**任何时候**都不会被系统回收。JVM宁愿抛出OOM异常，也不会回收强引用所指向的对象。
3.  可能导致内存泄漏。

> 若你的内存够大，无需考虑极致性能，所有引用都使用强引用也是ok的；强引用可直接访问，**是Java默认的引用方式**~

--------------------

**注意：我看到很多文章把`FinalReference`解释为强引用，这是错误的。**

/** * Final references, used to implement finalization */
    class FinalReference<T> extends Reference<T> { 
        public FinalReference(T referent, ReferenceQueue<? super T> q) { 
            super(referent, q);
        }
    }

从它的javadoc也能看出来，**这个类它和强引用没半毛钱关系**。它倒是和Object的`finalize()`方法有关。关于它的详细介绍，可参阅笨神的大作：[JVM源码分析之FinalReference完全解读][JVM_FinalReference]

关于`finalize`方法的使用，亦可参阅这篇文章：[java finalize方法总结、GC执行finalize的过程][java finalize_GC_finalize]

--------------------

#### 软引用 ####

> 软引用（Soft Reference)：是用来描述一些还有用**但并非必须**的对象。对于软引用对象，**如果内存`充足`(注意此处对充足二字的理解)gc不会管它，如果内存不够了，它就不能幸免了**。

public class SoftReference<T> extends Reference<T> { 
        static private long clock;
        private long timestamp;
    
    	// 提供了两个构造函数 可以构造软引用
        public SoftReference(T referent) { 
            super(referent);
            this.timestamp = clock;
        }
        public SoftReference(T referent, ReferenceQueue<? super T> q) { 
            super(referent, q);
            this.timestamp = clock;
        }
    
    	// 获取此软引用的对象
        public T get() { 
            T o = super.get();
            if (o != null && this.timestamp != clock)
                this.timestamp = clock;
            return o;
        }
    }

软引用是除了强引用外最强的引用类型。可以通过`java.lang.ref.SoftReference`使用软引用。

`SoftReference`的特点是它的一个实例**保存对一个Java对象**的软引用，该软引用的存在**不妨碍垃圾收集线程对该Java对象的回收**。  
也就是说，一旦`SoftReference`保存了对一个Java对象的软引用后，在垃圾线程对这个`Java`对象**回收前**，`SoftReference`类所提供的get()方法返回Java对象的**强引用**。一旦垃圾线程回收该Java对象**之后**，get()方法将返回null。

> 很多初学者不太能理解这块：一言以蔽之，它就是创建一个`SoftReference`对象，然后这个对象里面包装了obj（强引用对象），也就是对它实施了管理，最终实际存在的是两个对象哦（`SoftReference`自己变成了强引用，请务必注意这点）~

public class Main { 
    
        public static void main(String[] args) throws InterruptedException { 
            Person obj = new Person("fsx", 18);
            SoftReference sf = new SoftReference<>(obj);
            obj = null; //置为null 让obj被垃圾回收期回收
    
            //byte[] bytes = new byte[1024 * 100];
            //System.gc();
            //TimeUnit.SECONDS.sleep(1); // 把问题放大,让gc过来回收 确保GC肯定会执行
    
            System.out.println("是否被回收：" + sf.get());
        }
    
    }

运行时请调整虚拟机参数为：`-Xmx2m -Xms2m`规定堆内存大小为2m。  
![在这里插入图片描述][20190630120242285.png]  
运行结果：

是否被回收：Person{ name='fsx', age=18}

> 结果说明：当obj=null后，这时，Obj对象就只剩下软引用了，是`软可达`的。所以哪怕这个时候调用System.gc();也是**不会**被回收的（=null后置表示失去了obj这个引用，但是sf还软引用着你呢~~~）

`打开被注释掉`的`new byte[1024*100]`语句：这条语句请求**一块大的堆空间**，使堆内存使用紧张。并显式的**再调用一次GC**，结果如下：

是否被回收：null

obj对象已经被回收，**软可达已经变成了不可达**，这就是软引用的效果~

此处不知你是否**还能看**出一个问题：  
obj被gc回收后，`SoftReference sf`这个对象就成垃圾了，完全没用了，这个时候**建议你处理掉它**，否则可能造成内存泄漏现象（得不偿失呀）。所以`ReferenceQueue`队列上场啦（重要：生产环境中一般建议配合队列一起使用）：

> `ReferenceQueue`队列和JVM对象垃圾回收机制有关，垃圾回收器将已注册的引用对象添加到队列中，ReferenceQueue实现了入队（enqueue）和出队（poll），还有remove操作，内部元素head就是泛型的Reference

##### ReferenceQueue #####

`软引用可用来实现内存敏感的高速缓存`。软引用可以和一个引用队列（`ReferenceQueue`）联合使用，如果软引用所引用的对象被垃圾回收器回收，Java虚拟机就会把这个`软引用本身`加入到与之关联的引用队列中，方便你手动释放内存。

上例中`SoftReference sf`对象的内存回收的时候会经历一个过程：从`Active->Pending->Enqueued->Inactive`。`pending`状态就是等待着进入`ReferenceQueue`队列的这样一个状态，说白了**目标对象目前还没被回**收，只是对象的引用(此处的obj对象)**被移除了（=null）**，`pending`保存了这个引用，**并且放进ReferenceQueue里**(更详细的可咨询JVM的对象回收流程)。

> 这段话建议多读几遍，好好理解一番。 引用对象指向的对象 GC 会自动清理，**但是引用对象本身也是对象（是对象就占用一定资源），所以需要我们自己手动清理哦~**

so如下示例代码手动清理引用本身（强烈推荐这么做）：

public class Main { 
    
        public static void main(String[] args) throws InterruptedException { 
            //定义一个引用队列
            ReferenceQueue<Person> queue = new ReferenceQueue<>();
    
            Person obj = new Person("fsx", 18);
            SoftReference sf = new SoftReference<>(obj, queue); // 通过构造函数把Queue传进去 让此软引用关联上队列
            obj = null; //置为null 让obj被垃圾回收期回收
    
            System.gc();
            TimeUnit.SECONDS.sleep(2);
    
            byte[] bytes = new byte[1024 * 100];
            System.gc();
            TimeUnit.SECONDS.sleep(1); // 把问题放大,让gc过来回收 保证obj已经被回收
    
            System.out.println("是否被回收：" + sf.get());
            //队列里存在 说明对象马上就要被回收了 所以顺势也把软引用对象干掉
            if ((sf = (SoftReference<Person>) queue.poll()) != null) { 
                System.out.println("sf置为null，释放内存");
                sf = null;
            }
        }
    
    }

输出结果：

是否被回收：null
    sf置为null，释放内存

可见这么操作后，sf也被释放了。注意：若没有这句话`new byte[1024 * 100]`，内部不会紧张，obj也不会被回收，所以`sf置为null，释放内存`这句话也就不会被打印了

> 在实际生产环境中，我们可能会用个子线程专门去处理这个回收问题。  
> 说明：`poll()`方法不是阻塞方法，所以即使你在主线程里做，关系也不大。只不过这种事集中处理会比较好些

#### 弱引用 ####

> 弱引用（WeakReference）：**弱引用和软引用很像**，当gc时，**无论内存是否充足，`都会回收`被弱引用关联的对象**。  
> 它也可以和`ReferenceQueue`配合使用：如果弱引用所引用的对象被JVM回收，这个弱引用就会被加入到与之关联的引用队列中（使用方式同上示例）

public class WeakReference<T> extends Reference<T> { 
    	
    	// 仅仅提供了两个构造方法而已，注意它的get方法在父类Reference上
        public WeakReference(T referent) { 
            super(referent);
        }
        public WeakReference(T referent, ReferenceQueue<? super T> q) { 
            super(referent, q);
        }
    }

对它多一个使用Demo如下：

public class Main { 
    
        public static void main(String[] args) throws InterruptedException { 
            Person obj = new Person("fsx", 18);
            WeakReference sf = new WeakReference(obj);
            obj = null;
            System.out.println("是否被回收" + sf.get());
            System.gc();
            System.out.println("是否被回收" + sf.get());
        }
    
    }

输出：

是否被回收Person{ name='fsx', age=18}
    是否被回收null

可见即使内存是足够的，但只要GC了，它也会被回收。注意此时`WeakReference sf`它还在，为了避免成为垃圾，建议按照上面做处理。

--------------------

说明：**软引用，弱引用**都非常适合来保存那些**可有可无的缓存数据**，如果这么做，当系统内存不足时，这些缓存数据会被回收，不会导致内存溢出。**而当内存资源充足时**，这些缓存数据又可以存在相当长的时间，从而起到加速系统的作用。

> 但是高速缓存产品建议用软引用来做，毕竟内存如果充足的话，我们是并不希望清空缓存的（**如果每次gc都清空一次缓存，那么经常会出现缓存预热的情况，就一定程度上失去了缓存的意义了**）

--------------------

#### 虚引用 ####

> 虚引用（PhantomReference）：**虚引用和前面的软引用、弱引用不同**，它并不影响对象的`生命周期`（[java对象的生命周期][java]）。  
> 一个对象与虚引用关联，则**跟没有引用与之关联一样**，所以get()方法`永远`返回null，在**任何时候**都可能被垃圾回收器回收。因此它**必须**和`ReferenceQueue`一起使用，**否则没有任何意义**。  
> **它的作用一般在于跟踪垃圾回收过程（netty源码中有对此种引用的使用，非常巧妙，有兴趣可自己研究一下）**

public class PhantomReference<T> extends Reference<T> { 
    
    	// 它永远返回null
    	@Override
        public T get() { 
            return null;
        }
    
    	// 它只有这个一个构造函数：必须和ReferenceQueue一起使用~
        public PhantomReference(T referent, ReferenceQueue<? super T> q) { 
            super(referent, q);
        }
    }

当垃圾回收器**准备回收一个对象时**，如果发现它还有虚引用，就会在垃圾回收销毁这个对象之前，**将这个虚引用加入引用队列**。  
因此我们可以通过判断**引用队列中是否已经加入了虚引用**，来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的**内存被回收之前采取必要的行动（比如释放资源等等操作）**。

public class Main { 
    
        public static void main(String[] args) throws InterruptedException { 
            ReferenceQueue<Person> queue = new ReferenceQueue<>();
            Person obj = new Person("fsx", 18);
    
            PhantomReference sf = new PhantomReference<>(obj, queue);
            obj = null;
    
            System.out.println(sf.get());
            System.gc();
            TimeUnit.SECONDS.sleep(1);
            if ((sf = (PhantomReference<Person>) queue.poll()) != null) { 
                System.out.println("obj要销毁了，准备释放内存");
                sf = null;
            }
        }
    
    }

运行结果：

null
    obj要销毁了，准备释放内存

### `WeakHashMap`的使用 ###

JDK1.2既然推出了这四种引用类型，那么势必是有它的使用场景的。`WeakHashMap`它使用的是`WeakReference`若引用来实现的，WeakHashMap的键是**弱键**，对内存友好。它的**弱键实现原理步骤**：

1.  新建WeakHashMap，将“键值对”添加到WeakHashMap中（通过数组table保存Entry(键值对)；每一个Entry实际上是一个单向链表，即Entry是键值对链表）
2.  **当某“弱键”不再被其它对象引用，并被GC回收时。在GC回收该“弱键”时，这个“弱键”也同时会被添加到ReferenceQueue(queue)队列中**（这个步骤尤其重要）
3.  当下一次我们需要操作`WeakHashMap`时，**会先同步table和queue**。从table中删除调queue中被GC回收掉的那些键值对们（也就是说只有在**下一次调用**(任何)方法时才会来同步，才会把这个entry全部移除掉）。

从上原理可以得出，你在使用`WeakHashMap`时需要注意如下几点：

1.  和HashMap一样，WeakHashMap是不同步的。可以使用 Collections.synchronizedMap 方法来构造同步的 WeakHashMap
2.  Java木有提供`WeakHashSet`，但你可以通过`Collections.newSetFromMap(Map<E,Boolean> map)`方法可以将任何 Map包装成一个Set
3.  **请不要对此Map的key有持久性的强引用**，否则它就退化为HashMap了，不具有弱引用的特性了

我们平时经常使用`Map`来缓存数据，其实这样很多时候会造成大量的内存泄漏。下面用示例来证明这一点：

> 同样的，运行时请调整虚拟机参数为：`-Xmx2m -Xms2m`规定堆内存大小为2m。

public static void main(String[] args) throws InterruptedException { 
        Map<String, Object> map = new HashMap<>();
        for (int i = 0; i < 10000; i++) { 
            map.put("key" + i, new byte[i]);
        }
        System.out.println(map.size());
    }

结果如下：

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    	at com.fsx.maintest.Main.main(Main.java:16)

因为我们用的`HashMap`，所以最终内存不够就OOM了~

###### 使用`WeakHashMap`改进： ######

`WeakHashMap`类在`java.util`包内，它实现了`Map`接口，是`HashMap`的一种实现（但不是它的子类），它使用`弱引用`作为内部数据的**存储方案**。`WeakHashMap`是弱引用的一种**典型应用**，**它可以作为简单的缓存表解决方案**。

// @since 1.2 JDK1.2出来的
    public class WeakHashMap<K,V> extends AbstractMap<K,V> implements Map<K,V> { 
    	// 内部自己new了一个ReferenceQueue
        private final ReferenceQueue<Object> queue = new ReferenceQueue<>();
    	...
    	// 它使用若引用的核心主要是Entry这个内类
    	// 继承自WeakReference，这样一来，整个Entry就是一个WeakReferenc
        private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> { 
            Entry(Object key, V value,ReferenceQueue<Object> queue,int hash, Entry<K,V> next) { 
                super(key, queue); // 调用WeakReference的构造函数
                this.value = value;
                this.hash  = hash;
                this.next  = next;
            }
        }
    	...
    }

使用`WeakHashMap`改造如下（只改一行代码）：

public class Main { 
        public static void main(String[] args) throws InterruptedException { 
            // 只改变了这一句话而已~
            Map<String, Object> map = new WeakHashMap<>();
            for (int i = 0; i < 10000; i++) { 
                map.put("key" + i, new byte[i]);
            }
            System.out.println(map.size());
        }
    }

输出：

6（备注：这个值可能是10、20、100等等）

从结果中可以看出Map的`size()`长度不是`10000`了，也就是说出现了数据丢失~，但运行不会报OOM错误了。  
**由此可见，WeakHashMap会在系统内存紧张时使用弱引用，自动释放掉持有弱引用的内存数据。**

> 说明：如果`WeakHashMap`的key都在系统内**持有强引用**，那么`WeakHashMap`就退化为普通的`HashMap`，因为所有的项都无法被自动清理。**所以尽量不要使你的`WeakHashMap`里的key被强引用了，否则它将失去效果**~~~

当然我们也可以**自定义**一个基于`WeakReference`或者`SoftReference`的缓存结构，有兴趣自定义的可以参考这个示例：[java中SoftReference与WeakReference应用于高速缓存示例][java_SoftReference_WeakReference]

#### 为什么是弱键而不是弱值？ ####

这个问题你应该思考。`WeakHashMap`它就不是为缓存而设计的，因为它是弱键而不是弱值，而一般而言**值才是最占用内存空间的**，所以它天生就不太适合当作缓存来用（当然当缓存来用效果比HashMap肯定还是好点的）。

**`WeakHashMap`的经典使用场景是：保存您不控制生命周期的对象的元数据**。  
比如用于数据跟踪，一个简单的例子（和我以前用过的）可能是这样的：`WeakHashMap<Thread, SomeMetaData>`，可以跟踪你的系统中的各种线程在做什么，当线程死亡时，该条目将从您的映射中静默移除。所以你遍历就可以拿出**活动线程**的元数据喽。

作为缓存而言，我们是希望有个类似`Map<K,SoftReference<V>>`（弱值）的存储结构，那么接下来我就自己给出一个例子，可以给与你作为高速缓存来使用：

public class SoftReferenceCache<K, V> { 
    
        private static final int DEFAULT_MAP_SIZE = 1024; // 初始容量
        private Map<K, CacheReference<K, V>> softReferenceMap = new HashMap<>(DEFAULT_MAP_SIZE);
        private final ReferenceQueue<V> referenceQueue; // 方便从缓存池中清除失效的软引用
        private final ValueNotFoundProvider<K, V> objectNotFoundProvider; // 当key找不到的时候的处理函数
    
    
        // 若ObjectNotFoundHandler用户不指定，会采用默认的：啥都不做
        public SoftReferenceCache() { 
            this(null);
        }
    
        public SoftReferenceCache(ValueNotFoundProvider<K, V> handler) { 
            this.referenceQueue = new ReferenceQueue<>();
            this.objectNotFoundProvider = handler != null ? handler : (k) -> null;
        }
    
        public V put(K key, V value) { 
            // 清楚无效垃圾（也会从softReferenceMap里移除）
            clearInvalidReference();
            CacheReference<K, V> v = softReferenceMap.put(key, new CacheReference<>(key, value, referenceQueue));
            if (v == null) { 
                return null;
            }
            return v.get();
        }
    
    
        /** * 获取，若没获取到，会使用objectNotFoundProvider提供值 */
        public V get(K key) { 
            V value = null;
            CacheReference<K, V> ref = softReferenceMap.get(key);
            if (ref == null || (ref != null && ref.get() == null)) { 
                //软引用指向的对象被回收,并缓存该软引用
                value = this.objectNotFoundProvider.provideValue(key);
                if (value != null) { 
                    put(key, value);
                }
            }
            clearInvalidReference(); // 此时调用清理
            return value;
        }
    
        public boolean containsKey(K key) { 
            clearInvalidReference();
            return softReferenceMap.containsKey(key);
        }
    
        public int size() { 
            clearInvalidReference();
            return softReferenceMap.size();
        }
    
        public boolean isEmpty() { 
            return size() == 0;
        }
    
        public void clear() { 
            clearInvalidReference();
            softReferenceMap.clear();
        }
    
        public V remove(K key) { 
            clearInvalidReference();
            CacheReference<K, V> v = softReferenceMap.remove(key);
            if (v == null) { 
                return null;
            }
            return v.get();
        }
    
    
        /** * 根据已经被回收的value对应的key，是为了清除掉map里的键值对，防止本Cache的内存泄漏 */
        private void clearInvalidReference() { 
            CacheReference<K, V> cacheReference;
            while ((cacheReference = (CacheReference<K, V>) referenceQueue.poll()) != null) { 
                softReferenceMap.remove(cacheReference.getKey());
    
            }
        }
    
        /** * 缓存应用类，继承软引用 * 这里把key也保存起来，是因为清理的时候也得清理键值对，否则Map可能会内存泄漏的 */
        private static class CacheReference<K, V> extends SoftReference<V> { 
            private final K key;
            public CacheReference(K key, V reference, ReferenceQueue<V> queue) { 
                super(reference, queue);
                this.key = key;
            }
            public K getKey() { 
                return this.key;
            }
        }
    
        /** * 若缓存里木有，就交给使用者去获取（比如查库~~~） */
        @FunctionalInterface
        public interface ValueNotFoundProvider<K, V> { 
            V provideValue(K k);
        }
    
    }

#### 总结 ####

其实软引用、弱引用在`Android`这种移动端应用，**对内存更敏感**的应用中使用更多些，服务端毕竟对内存敏感度差点，所以没受到很多人的重视。但是这一块个人觉得在**设计高效的框架时，还是可以使用的~**  
Tips：谷歌不推荐使用软引用`SoftReference`，而建议使用弱引用`WeakReference`（但是我觉得通用的缓存设计用软引用，或许还更好些吧）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Y2NDEzODU3MTI_size_16_color_FFFFFF_t_70]

--------------------

# 关注A哥 #

<table> 
 <thead> 
  <tr> 
   <th>Author</th> 
   <th><a href="https://www.yourbatman.cn/about" rel="nofollow">A哥(YourBatman)</a></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>个人站点</td> 
   <td><a href="https://www.yourbatman.cn" rel="nofollow">www.yourbatman.cn</a></td> 
  </tr> 
  <tr> 
   <td>E-mail</td> 
   <td>yourbatman@qq.com</td> 
  </tr> 
  <tr> 
   <td><strong>微 信</strong></td> 
   <td><a href="https://www.yourbatman.cn/images/wechat.png" rel="nofollow">fsx641385712</a></td> 
  </tr> 
  <tr> 
   <td><strong><code>活跃平台</code></strong></td> 
   <td><a href="https://www.yourbatman.cn" rel="nofollow"><img src="https://img-blog.csdnimg.cn/2020071015182276.png" alt=""></a> <a href="https://fangshixiang.blog.csdn.net/" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151913394.png" alt=""></a><a href="https://yourbatman.cnblogs.com" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151929355.png" alt=""></a><a href="https://juejin.im/user/5b44d178f265da0fa1220efe/posts" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151938937.png" alt=""></a><a href="https://www.zhihu.com/people/fangshixiang/posts" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151950629.png" alt=""></a><a href="https://www.jianshu.com/u/8740f1fdd684" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710152000530.png" alt=""></a><a href="https://segmentfault.com/u/yourbatman/articles" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710152008726.png" alt=""></a><a href="https://github.com/yourbatman" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710152015895.png" alt=""></a></td> 
  </tr> 
  <tr> 
   <td><strong>公众号</strong></td> 
   <td><a href="https://www.yourbatman.cn/images/wechat_channel.jpg" rel="nofollow">BAT的乌托邦（ID：BAT-utopia）</a></td> 
  </tr> 
  <tr> 
   <td>知识星球</td> 
   <td><a href="https://t.zsxq.com/nQBi66I" rel="nofollow">BAT的乌托邦</a></td> 
  </tr> 
  <tr> 
   <td>每日文章推荐</td> 
   <td><a href="https://github.com/yourbatman/reading/issues" rel="nofollow">每日文章推荐</a></td> 
  </tr> 
 </tbody> 
</table>

![BAT的乌托邦][BAT]

[20190630114312940.png]: /images/20211220/27dab9c35753458384915a353e3c9f51.png
[JVM_FinalReference]: https://www.jianshu.com/p/65369496d0b6
[java finalize_GC_finalize]: https://www.cnblogs.com/Smina/p/7189427.html
[20190630120242285.png]: /images/20211220/4626a47545ec4151a9c588ae33167bcf.png
[java]: https://blog.csdn.net/sodino/article/details/38387049
[java_SoftReference_WeakReference]: https://www.cnblogs.com/xinxinBlog/p/10357890.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Y2NDEzODU3MTI_size_16_color_FFFFFF_t_70]: /images/20211220/22cdd5263ed642cba64635b3da81b06a.png
[BAT]: /images/20211220/13547df6e1aa452f9f197e1c1f68eb29.png