浅谈Java中的引用

在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)的情况显然会抛出空引用异常

浅谈Java中的引用

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

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

浅谈Java中的引用

通过实现可以知道,如果正在执行一个弱引用所指向内存的方法,那么这个虚弱引用是可以逃过这段时间内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不回或晚回收。强度弱的,即使对象还没有被回收,就无法通过引用获取到内存信息。

相关推荐