浅谈Java中的引用

在Java语言中，引用是指，某一个数据，代表的是另外一块内存的的起始地址，那么我们就称这个数据为引用。

在JVM中，GC回收的大致准则，是认定如果不能从根节点，根据引用的不断传递，最终指向到一块内存区域，我们就将这块内存区域回收掉。但是这样的回收原则未免太过粗暴。有些时候，内存的使用并不紧张，我们并不希望GC那么勤劳的、快速的回收掉内存。反而有时候希望数据可以在内存中尽可能的保留长一会，待到虚拟机内存吃紧的时候，再来清理掉他。因此从JDK1.2之后，引用的类型变的多样化，从而更好的适应编码的需要。

下面次来介绍下四种引用：

1、强引用 Strong Reference

这是Java程序中，最普遍的一种引用。

程序创建一个对象，并且把这个对象赋值给一个引用变量，我们就称这个引用变量为强引用。很多书上说，强引用是不会被GC回收掉的，个人觉得这话是需要背景的：即强引用变量所处的位置，一定是在GC回收，所判定的Root节点能够依次传递到的引用，如果出现孤立的循环引用。那么即使对象中，存在强引用，也一定是会被回收掉的。其次需要强调的就是强引用不被回收，一定要(防盗连接：本文首发自http://www.cnblogs.com/jilodream/ )处在强引用所在的作用域中，如方法栈已经弹出，那么栈帧中的局部变量表中的变量就会被回收，其中存在的强引用的指向关系也会被解除。当然叨叨这么多，只是想说，强引用是否被回收，一定要看具体的情况，而不能一概而论。

笔者认为，引用，就类似于生活中对物品的持有状态，如果一件物品，对我们至关重要，是必不可少的，无论如何打扫卫生我们都不可能会清理掉他们，那么这种关系状态，我们就认为是强引用。

2、软引用 Soft Reference

当一个对象的引用关系一直保留，GC就不会清理掉这个对象，我们称之为强引用。在平常的开发中，我们还希望有这样一种引用状态：只要内存够用，即使GC进行回收，我们仍然会一直保留，反之倘若内存不够用，那么下次GC回收时，就会处理掉强引用所指向的对象。

强引用可以理解为GC永远不会强制删除的引用，而软引用，则可以理解为，家中存放的可有可无的物件，比如可有可无的废弃的家具、电脑中已经不会再使用的软件、手机上保存的可能不会再翻阅浏览的信息、照片、视频。(防盗连接：本文首发自http://www.cnblogs.com/jilodream/ )对于这些东西，只要家中仍然有剩余的空间，手机中仍然有足够的硬盘空间，大部分人都会一直保留，直到手机废弃、家中拆迁。但是倘若，手机的硬盘空间开始吃紧、家中没有剩余的空间可供使用，很多人就会选择一次性的，把这些没用的东西全部都处理掉，尽管这些东西可能在以前的清理过程中，一直被保留。

Java的这种设计，正是为了模拟类似于生活中，对于鸡肋物件的关系。如果保存空间足够，那么久保留该物件，如果保存空间不足，那么才开始清理。

3、弱引用 Weak Reference

软引用让Jvm的内存管理，拥有弹性，可以根据使用情况动态的调整要回收的对象。弱引用与软引用的性质类似。不同之处在于，对于弱引用指向的对象，无论内存是否够用，下次GC回收时，都会回收掉该块内存。这就像我们平常打扫卫生，有些东西一直在使用，但是倘若要打扫卫生了，就一定会处理掉这些物品。即使房间内仍然有足够的空间，可以保留这些物品。

对于软引用和弱引用，在使用时，不可以再像原有强引用一般，直接给引用变量赋值，否则强引用关系会再次建立。这里则需要依赖java.lang.ref包下的几个类，使用方法可以参考如下代码：

 import java.lang.ref.SoftReference;
 import java.lang.ref.WeakReference;

 public class RefLearn
 {

     private static WeakReference<RefLearn> weakRef0;
     private static WeakReference<RefLearn> weakRef1;

     public static void main(String arg[]) throws InterruptedException
     {
         RefLearn refLearn = new RefLearn();
         refLearn.init();
     }

     private void init() throws InterruptedException
     {
         RefLearn obj = new RefLearn();
         SoftReference<RefLearn> softRef = new SoftReference<RefLearn>(obj);// 将实例传进来
         obj = null;// 切断原有的强引用，一般使用时，直接在构造函数中new 即可
         weakRef0 = new WeakReference<RefLearn>(new RefLearn());
         weakRef1 = new WeakReference<RefLearn>(new RefLearn());
         softRef.get().doNothing();
         if (weakRef0.get() != null)
         {
 //            System.gc();
 //            Thread.sleep(2000);
             Thread.sleep(1000);
             weakRef0.get().doSomething();
         }
         // obj = weakRef.get();// 这里会再次建立强引用，会阻止回收
     }

     private void doNothing()
     {

     }

     private void doSomething()
     {
         int i = 0;
         while (true)
         {
             try
             {
                 System.gc();
                 Thread.sleep(1000);
                 boolean relate0 = weakRef0.get() == null;
                 boolean relate1 = weakRef1.get() == null;
                 System.out.println(relate0 + " " + relate1 + " " + i++);
             }
             catch (InterruptedException e)
             {
             }
         }
     }
 }

代码中通过引用类的get()方法，可以获取到非强引用所指向的变量，同时使用它们。

通过上述代码，我们会发现两个问题

问题一

如果内存吃紧，那么是所有软引用都被回收，还是只回收尽可能少的软引用？

答案是后者，建立软引用后，引用对象会被打一个时间戳，标记该引用当前所处的GC时间，也就是这两个时间：

     /**
      * Timestamp clock, updated by the garbage collector
      */
    static private long clock;
     /**
      * Timestamp updated by each invocation of the get method.  The VM may use
      * this field when selecting soft references to be cleared, but it is not
      * required to do so.
      */
     private long timestamp;

当该软引用每次被调用get时，都会修改该引用的时间戳，来标识该引用指向变量的最后调用时间。GC会在回收过程中，优先回收一直不被使用的软引用。

问题二（这是一道大题，有两个小问(防盗连接：本文首发自http://www.cnblogs.com/jilodream/ )）

(1)在判断get()的取值是否为null后，再次使用时，如果这个期间，内存被回收了，怎么办？

(2)如果在执行弱引用执行的方法时，内存是否会被回收掉？

问题(1)的情况显然会抛出空引用异常

因此在使用软引用和弱引用时，务必要注意空引用异常。

问题(2)的情况我们可以看示例代码的运行结果：

通过实现可以知道，如果正在执行一个弱引用所指向内存的方法，那么这个虚弱引用是可以逃过这段时间内GC的回收的。其实想想也该明白，方法参数其实默认有this变量作为参数（这个以后会说）。同时方法栈帧中的局部变量表可能也会指向于堆中的其他变量，倘若直接回收，未来可能会指向无访问权限的内存区域，导致出现内存安全问题。

4、虚引用 Phantom Reference

Phantom ['fæntəm]

adj. 幽灵的；幻觉的；有名无实的

通过名称我们就可以发现，这个引用的强度属于微乎其微的。事实也的确如此。

我们几乎已经无法通过虚引用，查找到任何其所指向实例的内部信息。唯一可以获得的仅仅是该对象是否已经被回收（即是否已经经过一次GC过程）。如果非要用虚引用与现实生活中的某种联系相类比的话，个人觉得有点像已经丢弃到回收站中的文件，当我们打开回收站时，是不能直接使用这些软件的，只能判断这些软件有没有被回收掉，而如果真正想再次使用这些软件的话，需要再次建立关系性更强的引用才可以。

虚引用与上述的其他三个引用有比较大的区别。

我们先来看一段代码

 import java.lang.ref.PhantomReference;
 import java.lang.ref.ReferenceQueue;

 public class PhantomReferenceLearn
 {
     public void init() throws InterruptedException
     {
         ReferenceQueue<PhantomReferenceLearn> Refqueue = new ReferenceQueue<PhantomReferenceLearn>();
         PhantomReference<PhantomReferenceLearn> pr = new PhantomReference<PhantomReferenceLearn>(
                 new PhantomReferenceLearn(), Refqueue);
         System.gc();
         Thread.sleep(1000);
         boolean isClear = Refqueue.poll() == pr;
         System.out.println(isClear);
     }
 }

与软引用和弱引用不同的是，虚引用的构造函数只能同时伴随着一个引用队列来构造。当虚引用回收时，引用会被加载到构造时绑定的引用队列中，可以通过出队的方式来查看引用是否已经被回收。ps.与虚引用类似，软引用和弱引用也有类似的用法，不同的地方是虚引用只能这样使用。(防盗连接：本文首发自http://www.cnblogs.com/jilodream/ )

对于虚引用的使用还有以下几点要介绍

1)、由于虚引用在定义时，就已经明确其不可以通过引用关系，取出指向内存中的数据，因此尽管虚引用实例中也存有get()方法，但实际上一定返回的是null值，这点是在JDK代码中写死的：

注释的意思是返回一个对象的引用，但是由于虚引用是始终不可达的，因此始终返回null

     /**
      * Returns this reference object's referent.  Because the referent of a
      * phantom reference is always inaccessible, this method always returns
      * <code>null</code>.
      *
      * @return  <code>null</code>
      */
     public T get() {
         return null;
 }

2)、虚引用的回收时机

虚引用与弱引用类似，都是在GC阶段会被回收：

不同之处是弱引用在GC阶段，一旦发现对象是弱引用，即被插入ReferenceQueue队列中，而虚引用是在对象被销毁后才会被放入ReferenceQueue队列中。

3)、虚引用的必要性

乍看起来觉得虚引用存在的必要性非常弱，他的目的就是判断GC是否已经开始了回收，这点功能其实上弱引用完全可以达到。但是恰恰是虚引用的不可达性，有时是必要的。

如下面三种场景下：

(1)在处理数据时，我们希望有些保密数据的引用是完全切断的，不可达的。但是我们又希望可以知道这些数据是否已经被回收掉，那么这时可以考虑虚引用。

(2)在引用变量变量被赋予新值后，我们希望无论通过何种情况，旧有引用指向的变量的都不被重新建立强引用（可能是代码误操作，或者是攻击行为），这块内存的数据在下次GC期间会被永久的删除掉，这是也可以考虑虚引用。

(3)根据引用对象被插入到引用队列的时机，我们希望知道对象在完全被销毁后的时间点。

针对于第三个用途，很多人会疑惑，知道这个时间点，我们能有什么用呢？(防盗连接：本文首发自http://www.cnblogs.com/jilodream/ )这里先说一个题外话，搞过Java的人，基本都应该知道对象有一个和C++类似的回收方法：

protected void java.lang.Object.finalize()

这个方法需要各个需要调用的开发人员自己去复写。为的就是在对象析构的时刻做很多事情。但是对象从回收到调用析构方法被调用是一个非常复杂的过程（这个我以后会讲），所以在很多书中都介绍，不要去复写析构方法，如注明的《Effective Java》。但是很多时候我们万不得已，必须要在当前类被回收的时候做出一些行为。这时候就可以通过虚引用的形式，判断当前对象是否已经被加入到引用队列中，如果已经添加，那么做出相应的行为即可。

这样基本上就把四种引用的含义和使用多介绍完了。

最后的最后，很多人会认为引用的优先级如下：强引用>软引用>弱引用>虚引用。

这里个人觉得没必要扯到优先级上，四种引用各有优劣，唯一的区别就是引用对象与内存之间的关系强度的大小。强度大的，可以让JVM不回或晚回收。强度弱的，即使对象还没有被回收，就无法通过引用获取到内存信息。