旭日Follow_24 的CSDN 博客 ，全文地址请点击：
 
一、强引用
 
如下是强引用的经典形式：
 
object o = new object();
 
特点：
 
(1)创建一个对象，并将对这个对象的引用赋值给o，这样就是强引用了
 
(2)当内存空间不足的时候，虚拟机宁愿抛出错误，也不愿意回收内存
 
(3)可以使用 o = null；的方式来弱化引用
 
(4)如果一个对象，没有一个引用来指向他，那么这个引用可以被垃圾回收
 
二、软引用
 
softReference softRef = new softReference(str);
 
特点：
 
(1)软引用可以实现内存敏感的高速缓存
 
(2)当内存空间不足的时候，就回收这些对象
 
(3)hold on until you can't
 
三、弱引用
 
WeakReference weakRef = new WeakReference(str);
 
(1)弱引用和软引用的区别在于其拥有更短的生命周期
 
(2)不管当前的内存空间是否足够，都会回收他的内存
 
(3)偶尔才使用到的对象，我们使用弱引用的机制
 
四、总结
 
他们之间的关系：SoftReference >WeakReference > PhantomReference
 
如下是几种引用的回收和生命周期图
 
​

 
背景
 
工程中用到guava的本地缓存。它底层实现和API接口上使用了强引用、软引用、弱引用。所以温故知新下，也夯实下基础。
 
预备知识
 
先来看下GC日志每个字段的含义
 
Young GC示例解释
 
[GC (Allocation Failure) [PSYoungGen: 273405K->20968K(278016K)] 480289K->473619K(737792K), 0.1090103 secs] [Times: user=0.19 sys=0.27, real=0.11 secs]
 
解释
 
[GC(产生GC的原因，例子中是由于分配内存失败)  [PSYoungGen: 年轻代回收前空间->年轻代回收后空间(年轻代总空间)] 堆区的回收前空间->堆区的回收后空间(堆区的总空间), GC耗时] [Times: 用户空间耗时 系统空间耗时, 实际耗时]
 
Full GC示例解释
 
[Full GC (Ergonomics) [PSYoungGen: 20968K->20805K(278016K)] [ParOldGen: 452651K->451654K(864256K)] 473619K->472460K(1142272K), [Metaspace: 5793K->5793K(1056768K)], 0.1565987 secs] [Times: user=0.70 sys=0.00, real=0.16 secs]
 
解释
 
[Full GC (产生GC原因，例子中是由于要放入老年代的对象超过了老年代的剩余空间) [PSYoungGen: ->年轻代回收前空间->年轻代回收后空间(年轻代总空间)] [ParOldGen: 老年代回收前空间->老年代回收后空间(老年代总空间)] 堆区的回收前空间->堆区的回收后空间(堆区的总空间), [Metaspace: 元空间的回收前空间->元空间的回收后空间(元空间的总空间)],  GC耗时] [Times: 用户空间耗时 系统空间耗时, 实际耗时]
 
创建一个10M的大对象，重写finalize方法。finalize()方法会在对象被回收前调用，一个对象只有一次被调用的机会。对象可以在这个方法里进行自救，逃过被垃圾回收。Java设计这个方法可以被覆写是为了让有些对象在回收前做一些检查，完成一些前置条件再被垃圾回收。正式代码不建议使用。因为是测试，所以为了验证效果，这里打印GC日志信息。
 
byte[] bytes = new byte[10 * 1024 * 1024];intindex;public Ref(intindex) {this.index =index;
 
}public byte[] getBytes() {returnbytes;
 
}
 
@Overridepublic voidfinalize() {
 
System.out.println("index" + index + "'s" + bytes.length + "is going to be GG");
 
}
 
}
 
为了测试，JVM参数统一为-Xms20M -XX:+PrintGCDetails。Xms20M表示堆内存设置最大为20M，-XX:+PrintGCDetails代表打印详细的GC信息。
 

 
强引用
 
先来做个实验(代码已经上传github:https://github.com/xiexiaojing/yuna)
 
@Test
 
public void testRawStrong() {
 
List list = Lists.newArrayList();
 
for(int i=0; i<100; i++) {
 
list.add(new Ref(i));
 
System.out.println(list.get(i));
 
}
 
}
 
这段代码由上线的设置可知，由于最大设置20M堆空间，所以很快触发了GC。
 

 
不过Xmx这个值是建议内存最大使用值。如果内存使用超过这个值，jvm认为还有内存可以使用，也会将对象一直往堆里面放。所以2次GC之后JVM自动扩容了，之后就不再频繁GC。最终用到了满足程序需要的内存。
 

 
强引用是直接new出来调用的对象，大家都知道。由上面实验可知，在系统内存很富裕的情况下，因为强引用内存不能被释放，所以会多申请了很多内存。
 
软引用
 
软引用会在系统将要发生内存溢出异常之前，将会把这些软引用对象列进回收范围进行第二次回收。如果这次回收还没有足够的内存，才会抛出内存溢出异常。
 
用实验说明一下，为了防止JVM自动调整堆大小，我们把堆设置-Xmx200M。
 
@Test
 
public void testRawSoft() {
 
List> list = Lists.newArrayList();
 
for(int i=0; i<100; i++) {
 
list.add(new SoftReference<>(new Ref(i)));
 
System.out.println(list.get(i).get());
 
}
 
}
 
从下面实验结果可以看到数次的 GC之后，内存要撑不住的时候，Ref的软引用对象触发了finalize方法。这意味着它将要被内存回收了。说明GC会引发软引用里对象的内存回收，即使这个软引用本身还被强引用(list调用)着。
 

 
最终回收了这些内存也不能避免OOM的结局：
 

 
因为软引用通常情况下就是这样，只有内存马上要溢出了才触发它的GC。就好像扁鹊见蔡桓公的时候，蔡桓公的病已经很深了，马上就没救了。所以有了下面弱引用的方法：有病早治。
 
弱引用
 
弱引用是发生了一次垃圾回收后，既存的弱引用对象就开始回收。通常，一个弱引用对象仅能生存到下一次垃圾回收前。
 
用实验说明一下，为了防止JVM自动调整堆大小，我们把堆设置-Xmx200M。
 
@Test
 
public void testRawWeak() {
 
List> list = Lists.newArrayList();
 
for(int i=0; i<100; i++) {
 
list.add(new WeakReference<>(new Ref(i)));
 
System.out.println(list.get(i).get());
 
}
 
}
 
从下面的实验结果可知在发生了一次GC之后，已经生成的软引用对象都都回收了。下一次GC，这中间产生的软引用对象也都被回收了。
 

 
最终，由于GC及时，整个过程没有爆发OOM，平安的结束了。
 

 
虚引用
 
虚引用也叫幻影引用。任何时候可能被GC回收，就像没有引用一样。
 
并且他必须和引用队列一起使用，用于跟踪垃圾回收过程，当垃圾回收器回收一个持有虚引用的对象时，在回收对象后，将这个虚引用对象加入到引用队列中，用来通知应用程序垃圾的回收情况。
 
先来实验一下，从下面结果可看到从一开始取出来就是空对象，基本上刚创建出来就被回收了。
 

 
一个像是从来没有存在过的幻影有什么用呢？Java的Unsafe类和NIO都可以直接访问堆外内存。堆外内存GC管不了，这时候虚引用就排上用场了。我们可以通过引用队列跟踪垃圾回收，做好善后。
 
在Guava中使用强软弱引用
 
@Testpublic voidtestStrong() {
 
Cache cache = CacheBuilder.newBuilder().expireAfterAccess(1, TimeUnit.DAYS).build();for(int i=0; i<100; i++) {
 
cache.put(i,newRef(i));
 
System.out.println(cache.getIfPresent(i));
 
}
 
System.out.println(cache.stats().loadSuccessCount());
 
}
 
@Testpublic voidtestSoft() {
 
Cache cache =CacheBuilder.newBuilder().softValues().build();for(int i=0; i<100; i++) {
 
cache.put(i,newRef(i));
 
System.out.println(cache.getIfPresent(i));
 
}
 
}
 
@Testpublic voidtestWeak() {
 
Cache cache =CacheBuilder.newBuilder().weakKeys().weakValues().build();for(int i=0; i<100; i++) {
 
cache.put(i,newRef(i));
 
System.out.println(cache.getIfPresent(i));
 
}
 
}
 
Guava在没有显示设置强、软、弱引用的情况下默认是强引用。这个结论我没有看任何书，而是通过跟踪源码，debug得到的结论。当显示设置为软引用或者弱引用时，运行时GC触发和对象回收之间的关系和自己手动直接测试的结果是一样的，大家可以动手实践下。
 
总结
 
Java的强软弱虚引用被回收的时机不同：强引用是引用被释放才会回收；软引用是没释放，但是快OOM了就会被回收；弱引用是引用没释放，但是发生了GC后就会被回收；虚引用随时会回收，好像没有存在过，但是会有一个队列来跟踪它的垃圾回收情况。
 
相关阅读

 

 
先看再点赞，给自己一点思考的时间，如果对自己有帮助，关注这个执着的职场程序员。
 
价值：Java技能，面试经验指导，简历优化，职场规划指导，技能提升方法，讲不完的职场故事，个人成长经验。
 
Hello 大家好，我是【耳东双月】一个执着的职场程序员，为了让自己心里踏实，减少焦虑，同时验证自己的技术是不是脱钩了，决定面试一下大厂，首先面试了zj，面试的时候第一个问题就问了我 强引用，弱引用，虽然是基础题，但是问了几个同事，发现他们竟然说不出来个所以然来，所以我将我面试的题一个一个的整理出来，与大家分析，也让大家熟悉一些，会的加深，不会的学习，共勉之。。。。。
 
后续会一个一个来，一次写太多了反而不太容易看，再说整理需要时间，不想简单的带过，毕竟每一次经历都是需要成长的。
 
01
 
概念
 
1，强引用(StrongReference)
 
强引用是使用最普遍的引用。如果一个对象具有强引用，那垃圾回收器绝不会回收它
 
2，软引用(SoftReference)
 
如果一个对象只具有软引用，则内存空间充足时，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。
 
3，弱引用(WeakReference)
 
弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。
 
4，虚引用(PhantomReference)
 
虚引用顾名思义，就是形同虚设。与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。
 
概念性东西上面已经说的很详细了，我猜很多人不知道这么使用？并且不知道这些都用来做什么？
 
其实这里的主要用的还是使用弱引用，也是我们来讲的重点。虚引用主要用来跟踪对象被垃圾回收器回收的活动。
 
02
 
重要性和整理Java中4种引用的级别和强度由高到低依次为：强引用 -> 软引用 -> 弱引用 -> 虚引用
 
当垃圾回收器回收时，某些对象会被回收，某些不会被回收。垃圾回收器会从根对象Object来标记存活的对象，然后将某些不可达的对象和一些引用的对象进行回收。
 
通过表格来说明一下，如下：
 
03
 
作用于内存泄漏
 
Java中的内存泄露
 
假如在你的程序中有某类的对象很可能会造成内存泄漏，内存泄漏就是虚拟机在做垃圾回收时 某些垃圾 由于某些原因无法回收，而且每次实例化出来的对象都无法回收，最终导致内存超出。
 
这种内存泄漏是无法避免的，那么我们是否可以通过其他方式来检查内存泄漏？
 
这样就需要通过使用弱引用来处理，他能很好的判断某个对象类有没有被GC回收，被弱引用关联的对象只能生存到下一次垃圾回收发生之前，如果某个类即和弱引用关联有和强引用关联那么他就不会被回收。
 
根据这些就可以判断是否有内存泄漏。
 
在实际的实现中可以通过WeakHashMap来实现弱引用，只需将对象put到
 
WeakHashMap中。
 
例如：weakMap.(“a”，maybeMemoryLeak)，当maybeMemoryLeak及其包含的元素没有被其他任何类加载器中的元素引用到时，Jvm发生垃圾回收时会把maybeMemoryLeak对象回收，否则就将一直会不了回收。
 
通过内存泄漏这里的说明是不是指导 引用到底是怎么回事了？
 
其实说白了就是 通过引用来回收内存或者监控内存泄漏。
 
04
 
引用的使用
 
弱引用可以对内存进行回收，防止内存泄漏，例如：当一个内存对象失去了所有的引用之后，GC 就可以将其回收。反过来说，如果这个对象还存在引用，那么它将不会被 GC 回收，哪怕是 Java 虚拟机抛出 OutOfMemoryError 。
 
在Java中，内存泄漏就是存在一些被分配的对象，这些对象有下面两个特点，首先，这些对象是可达的，即在有向图中，存在通路可以与其相连；
 
其次，这些对象是无用的，即程序以后不会再使用这些对象。如果对象满足这两个条件，这些对象就可以判定为Java中的内存泄漏，这些对象不会被GC所回收，然而它却占用内存。一般来说是长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露，尽管短生命周期对象已经不再需要，但是因为长生命周期对象持有它的引用而导致不能被回收。
 
我们来看一个典型的内存泄露实例，这个也是很普遍的一个例子，通过该例子我们能更好分析：
 
Vector v=new Vector(10);
 
for (int i=1;i<100; i++){
 
Object o=new Object();
 
v.add(o);
 
/**
 
* 此时，所有的Object对象都没有被释放，因为变量v引用这些对象
 
*/
 
o=null;
 
}
 
解释：
 
我们循环申请Object对象，并将所申请的对象放入一个Vector中，如果我们仅仅释放引用本身，那么Vector仍然引用该对象，所以这个对象对GC来说是不可回收的。
 
因此，如果对象加入到Vector后，还必须从Vector中删除，最简单的方法就是将Vector对象设置为null。
 
通过上面的分析，我们来总结一下：
 
1、 GC 在一般情况下不会发现软引用的内存对象，只有在内存明显不足的时候才会发现并释放软引用对象的内存。
 
2、 GC 对弱引用的发现和释放也不是立即的，有时需要重复几次 GC ，才会发现并释放弱引用的内存对象。
 
3、软引用和弱引用在添加到 ReferenceQueue 的时候，其指向真实内存的引用已经被置为空了，相关的内存也已经被释放掉了。而虚引用在添加到 ReferenceQueue 的时候，内存还没有释放，仍然可以对其进行访问。
 
下面我们来一个一个说一下程序中这么使用：
 
(一) 强引用(StrongReference)
 
强引用是使用最普遍的引用，平常我们随意的一个 new对象就是一个强引用。如果一个对象具有强引用，那垃圾回收器绝不会回收它。如下：
 
Object strongReference = new Object();
 
(二) 软引用(SoftReference)
 
如果一个对象只具有软引用，则内存空间充足时，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。
 
// 强引用
 
String strongReference = new String("abc");
 
// 软引用
 
String str = new String("abc");
 
SoftReference softReference = new
 
SoftReference(str);
 
通过代码可以看出弱引用 使用 SoftRefrence来实现。使用起来很简单。
 
还有另一种方式也是引用队列。
 
软引用可以和引用队列(ReferenceQueue)联合使用。如果软引用所引用对象被垃圾回收，JAVA虚拟机就会把这个软引用加入到与之关联的引用队列中。
 
ReferenceQueue referenceQueue = new ReferenceQueue<>();
 
String str = new String("abc");
 
SoftReference softReference = new
 
SoftReference<>(str, referenceQueue);
 
str = null;
 
// Notify GC
 
System.gc();
 
System.out.println(softReference.get()); // abc
 
Reference extends String> reference = referenceQueue.poll();
 
System.out.println(reference); //null注意：软引用对象是在jvm内存不够的时候才会被回收，我们调用System.gc()方法只是起通知作用，JVM什么时候扫描回收对象是JVM自己的状态决定的。就算扫描到软引用对象也不一定会回收它，只有内存不够的时候才会回收。
 
当内存不足的时候软引用这么回收内存的呢？
 
当内存不足时，JVM首先将软引用中的对象引用置为null，然后通知垃圾回收器进行回收：
 
if(JVM内存不足) {
 
// 将软引用中的对象引用置为null
 
str = null;
 
// 通知垃圾回收器进行回收
 
System.gc();
 
}
 
也就是说，垃圾收集线程会在虚拟机抛出OutOfMemoryError之前回收软引用对象，而且虚拟机会尽可能优先回收长时间闲置不用的软引用对象。
 
我们再来看一个我们做web开发时候需要考虑的引用场景：
 
浏览器的后退按钮。按后退时，这个后退时显示的网页内容是重新进行请求还是从缓存中取出呢？这就要看具体的实现策略了。如果一个网页在浏览结束时就进行内容的回收，则按后退查看前面浏览过的页面时，需要重新构建；
 
如果将浏览过的网页存储到内存中会造成内存的大量浪费，甚至会造成内存溢出。
 
这时候就可以使用软引用，很好的解决了实际的问题：
 
代码如下：
 
// 获取浏览器对象进行浏览
 
Browser browser = new Browser();
 
// 从后台程序加载浏览页面
 
BrowserPage page = browser.getPage();
 
// 将浏览完毕的页面置为软引用
 
SoftReference softReference = new SoftReference(page);
 
// 回退或者再次浏览此页面时
 
if(softReference.get() != null) {
 
// 内存充足，还没有被回收器回收，直接获取缓存
 
page = softReference.get();
 
} else {
 
// 内存不足，软引用的对象已经回收
 
page = browser.getPage();
 
// 重新构建软引用
 
softReference = new SoftReference(page);
 
}
 
(三) 弱引用(WeakReference)
 
我们先来看弱引用与软引用的区别。
 
其实弱引用和软引用的区别不大，只是弱引用的对象拥有更短暂的生命周期。
 
由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。
 
String str = new String("abc");
 
WeakReference weakReference = new WeakReference<>(str);
 
str = null;
 
JVM首先将软引用中的对象引用置为null，然后通知垃圾回收器进行回收：
 
str = null;
 
System.gc();
 
(四) 虚引用(PhantomReference)
 
虚引用其实作用不大，我能几乎也不用，就是形同虚设。与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。
 
虚引用主要用来跟踪对象被垃圾回收器回收的活动。虚引用必须和引用队列(ReferenceQueue)联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。
 
String str = new String("abc");
 
ReferenceQueue queue = new ReferenceQueue();
 
// 创建虚引用，要求必须与一个引用队列关联
 
PhantomReference pr = new PhantomReference(str, queue);如果觉得对你有帮助，欢迎关注我留言，第一时间阅读。别忘了三连啊，点赞、收藏、留言，随意给，我不挑。
 
注：如果文章有任何问题，欢迎毫不留情地指正。

 
强引用(Strong Reference)
 
强引用就是我们经常使用的引用，其写法如下StringBuffer buffer = new StringBuffer();
 
上面创建了一个StringBuffer对象，并将这个对象的(强)引用存到变量buffer中。是的，就是这个小儿科的操作(请原谅我这样的说 法)。强引用最重要的就是它能够让引用变得强(Strong)，这就决定了它和垃圾回收器的交互。具体来说，如果一个对象通过一串强引用链接可到达 (Strongly reachable)，它是不会被回收的。如果你不想让你正在使用的对象被回收，这就正是你所需要的。
 
但是强引用如此之强
 
在一个程序里，将一个类设置成不可被扩展是有点不太常见的，当然这个完全可以通过类标记成final实现。或者也可以更加复杂一些，就是通过内部包 含了未知数量具体实现的工厂方法返回一个接口(Interface)。举个例子，我们想要使用一个叫做Widget的类，但是这个类不能被继承，所以无法 增加新的功能。
 
但是我们如果想追踪Widget对象的额外信息，我们该怎么办？ 假设我们需要记录每个对象的序列号，但是由于Widget类并不包含这个属性，而且也不能扩展导致我们也不能增加这个属性。其实一点问题也没有，HashMap完全可以解决上述的问题。serialNumberMap.put(widget, widgetSerialNumber);
 
这表面看上去没有问题，但是widget对象的强引用很有可能会引发问题。我们可以确信当一个widget序列号不需要时，我们应该将这个条目从 map中移除。如果我们没有移除的话，可能会导致内存泄露，亦或者我们手动移除时删除了我们正在使用的widgets，会导致有效数据的丢失。其实这些问 题很类似，这就是没有垃圾回收机制的语言管理内存时常遇到的问题。但是我们不用去担心这个问题，因为我们使用的时具有垃圾回收机制的Java语言。
 
另一个强引用可能带来的问题就是缓存,尤其是像图片这样的大文件的缓存。假设你有一个程序需要处理用户提供的图片，通常的做法就是做图片数据缓存，因为从磁盘加载图片代价很大，并且同时我们也想避免在内存中同时存在两份一样的图片数据。
 
缓存被设计的目的就是避免我们去再次加载哪些不需要的文件。你会很快发现在缓存中会一直包含一个到已经指向内存中图片数据的引用。使用强引用会强制 图片数据留在内存，这就需要你来决定什么时候图片数据不需要并且手动从缓存中移除，进而可以让垃圾回收器回收。因此你再一次被强制做垃圾回收器该做的工 作，并且人为决定是该清理到哪一个对象。
 
在 Java 中最常见的就是强引用，把一个对象赋给一个引用变量，这个引用变量就是一个强引用。当一个对象被强引用变量引用时，它处于可达状态，它是不可能被垃圾回收机制回收的，即使该对象以后永远都不会被用到JVM 也不会回收。因此强引用是造成Java 内存泄漏的主要原因之一。
 
弱引用
 
弱引用需要用WeakReference 类来实现，它比软引用的生存期更短，对于只有弱引用的对象来说，只要垃圾回收机制一运行，不管 JVM 的内存空间是否足够，总会回收该对象占用的内存。
 
弱引用简单来说就是将对象留在内存的能力不是那么强的引用。使用WeakReference，垃圾回收器会帮你来决定引用的对象何时回收并且将对象从内存移除。创建弱引用如下
 
WeakReference weakWidget = new WeakReference(widget);
 
使用weakWidget.get()就可以得到真实的Widget对象，因为弱引用不能阻挡垃圾回收器对其回收，你会发现(当没有任何强引用到widget对象时)使用get时突然返回null。
 
解决上述的widget序列数记录的问题，最简单的办法就是使用Java内置的WeakHashMap类。WeakHashMap和HashMap 几乎一样，唯一的区别就是它的键(不是值!!!)使用WeakReference引用。当WeakHashMap的键标记为垃圾的时候，这个键对应的条目 就会自动被移除。这就避免了上面不需要的Widget对象手动删除的问题。使用WeakHashMap可以很便捷地转为HashMap或者Map。
 
虚引用需要PhantomReference 类来实现，它不能单独使用，必须和引用队列联合使用。虚引用的主要作用是跟踪对象被垃圾回收的状态。