精华内容
下载资源
问答
  • Java四种引用类型

    2020-10-25 23:53:08
    Java四种引用类型:强引用、软引用、弱引用、虚引用 Java中的四种引用 Java中有四种引用类型:强引用、软引用、弱引用、虚引用。 Java为什么要设计这四种引用 Java的内存分配和内存回收,都不需要程序员负责,...

    Java四种引用类型:强引用、软引用、弱引用、虚引用

     

    Java中的四种引用

    Java中有四种引用类型:强引用、软引用、弱引用、虚引用。

    Java为什么要设计这四种引用

    Java的内存分配和内存回收,都不需要程序员负责,都是由伟大的JVM去负责,一个对象是否可以被回收,主要看是否有引用指向此对象,说的专业点,叫可达性分析。

    Java设计这四种引用的主要目的有两个:

    1. 可以让程序员通过代码的方式来决定某个对象的生命周期;

    2. 有利用垃圾回收。

    强引用

    强引用是最普遍的一种引用,我们写的代码,99.9999%都是强引用:

    Object o = new Object();
    

    这种就是强引用了,是不是在代码中随处可见,最亲切。 

    只要某个对象有强引用与之关联,这个对象永远不会被回收,即使内存不足,JVM宁愿抛出OOM,也不会去回收。

    那么什么时候才可以被回收呢?当强引用和对象之间的关联被中断了,就可以被回收了。

    我们可以手动把关联给中断了,方法也特别简单:

    o = null;
    

    我们可以手动调用GC,看看如果强引用和对象之间的关联被中断了,资源会不会被回收,为了更方便、更清楚的观察到回收的情况,我们需要新写一个类,然后重写finalize方法,下面我们来进行这个实验:

    public class Student {    @Override
        protected void finalize() throws Throwable {
            System.out.println("Student 被回收了");
        }
    }
    
    public static void main(String[] args) {
        Student student = new Student();
        student = null;
        System.gc();
    }
    

    运行结果:

    Student 被回收了
    

    可以很清楚的看到资源被回收了。

    当然,在实际开发中,千万不要重写finalize方法

    在实际的开发中,看到有一些对象被手动赋值为NULL,很大可能就是为了“特意提醒”JVM这块资源可以进行垃圾回收了。点击这里获取一份 JVM 实战教程。

     

    软引用

    下面先来看看如何创建一个软引用:

     SoftReference<Student>studentSoftReference=new SoftReference<Student>(new Student());
    

    软引用就是把对象用SoftReference包裹一下,当我们需要从软引用对象获得包裹的对象,只要get一下就可以了:

    SoftReference<Student>studentSoftReference=new SoftReference<Student>(new Student());
    Student student = studentSoftReference.get();
    System.out.println(student);
    

    软引用有什么特点呢: 

    当内存不足,会触发JVM的GC,如果GC后,内存还是不足,就会把软引用的包裹的对象给干掉,也就是只有在内存不足,JVM才会回收该对象。

    还是一样的,必须做实验,才能加深印象:

    SoftReference<byte[]> softReference = new SoftReference<byte[]>(new byte[1024*1024*10]);
    System.out.println(softReference.get());
    System.gc();
    System.out.println(softReference.get());        
    byte[] bytes = new byte[1024 * 1024 * 10];
    System.out.println(softReference.get());
    

    我定义了一个软引用对象,里面包裹了byte[],byte[]占用了10M,然后又创建了10Mbyte[]。

    运行程序,需要带上一个参数:

    -Xmx20M
    

    代表最大堆内存是20M。

    运行结果:

    [B@11d7fff
    [B@11d7fff
    null
    

    可以很清楚的看到手动完成GC后,软引用对象包裹的byte[]还活的好好的,但是当我们创建了一个10M的byte[]后,最大堆内存不够了,所以把软引用对象包裹的byte[]给干掉了,如果不干掉,就会抛出OOM。

    软引用到底有什么用呢?比较适合用作缓存,当内存足够,可以正常的拿到缓存,当内存不够,就会先干掉缓存,不至于马上抛出OOM。说到缓存,大家可以关注微信公众号Java技术栈获取更多干货。

    弱引用

    弱引用的使用和软引用类似,只是关键字变成了WeakReference:

    WeakReference<byte[]> weakReference = new WeakReference<byte[]>(new byte[1024\*1024\*10]);
    System.out.println(weakReference.get());
    

    弱引用的特点是不管内存是否足够,只要发生GC,都会被回收:

    WeakReference<byte[]> weakReference = new WeakReference<byte[]>(new byte[1]);
    System.out.println(weakReference.get());
    System.gc();
    System.out.println(weakReference.get());
    

    运行结果:

    [B@11d7fffnull
    

    可以很清楚的看到明明内存还很充足,但是触发了GC,资源还是被回收了。 
    弱引用在很多地方都有用到,比如ThreadLocal、WeakHashMap。

    虚引用

    虚引用又被称为幻影引用,我们来看看它的使用:

    ReferenceQueue queue = new ReferenceQueue();
    PhantomReference<byte[]> reference = new PhantomReference<byte[]>(new byte[1], queue);
    System.out.println(reference.get());
    

    虚引用的使用和上面说的软引用、弱引用的区别还是挺大的,我们先不管ReferenceQueue 是个什么鬼,直接来运行:

    null
    

    竟然打印出了null,我们来看看get方法的源码:

    public T get() {        
      return null;
    }
    

    这是几个意思,竟然直接返回了null。

    这就是虚引用特点之一了:无法通过虚引用来获取对一个对象的真实引用。

    那虚引用存在的意义是什么呢?这就要回到我们上面的代码了,我们把代码复制下,以免大家再次往上翻:

    ReferenceQueue queue = new ReferenceQueue();
    PhantomReference<byte[]> reference = new PhantomReference<byte[]>(new byte[1], queue);
    System.out.println(reference.get());
    

    创建虚引用对象,我们除了把包裹的对象传了进去,还传了一个ReferenceQueue,从名字就可以看出它是一个队列。

    虚引用的特点之二就是 虚引用必须与ReferenceQueue一起使用,当GC准备回收一个对象,如果发现它还有虚引用,就会在回收之前,把这个虚引用加入到与之关联的ReferenceQueue中。

    我们来用代码实践下吧:

    ReferenceQueue queue = new ReferenceQueue();
    List<byte[]> bytes = new ArrayList<>();
    PhantomReference<Student> reference = new PhantomReference<Student>(new Student(),queue);
    new Thread(() -> {
        for (int i = 0; i < 100;i++ ) {
            bytes.add(new byte[1024 * 1024]);
        }
    }).start();
    
    new Thread(() -> {
        while (true) {
            Reference poll = queue.poll();
            if (poll != null) {
                System.out.println("虚引用被回收了:" + poll);
            }
        }
    }).start();
    Scanner scanner = new Scanner(System.in);
    scanner.hasNext();
    }
    

    运行结果:

    Student 被回收了
    虚引用被回收了:java.lang.ref.PhantomReference@1ade6f1
    

    我们简单的分析下代码: 
    第一个线程往集合里面塞数据,随着数据越来越多,肯定会发生GC。 
    第二个线程死循环,从queue里面拿数据,如果拿出来的数据不是null,就打印出来。

    从运行结果可以看到:当发生GC,虚引用就会被回收,并且会把回收的通知放到ReferenceQueue中。

    虚引用有什么用呢?在NIO中,就运用了虚引用管理堆外内存.

    
     

     

    展开全文
  • JAVA四种引用类型

    2019-03-25 17:34:00
    java四种引用类型 我们知道在java中引用也是一种数据类型,需要在stack中申请内存来保存引用,这点类似C语言中的指针,还不知道什么是引用的推荐这篇博客java值类型和引用类型。 java对象的引用分为四种:强引用、软...

    java四种引用类型

    我们知道在java中引用也是一种数据类型,需要在stack中申请内存来保存引用,这点类似C语言中的指针,还不知道什么是引用的推荐这篇博客java值类型和引用类型

    java对象的引用分为四种:强引用、软引用、弱引用、虚引用

    java提供不同引用类型的目的有两个:

    1,让程序员可以通过代码决定对象的生命周期。

    2,利于JVM进行垃圾回收。

    一,分别用一句话总结四种引用的异同

    1,强引用

    具有强引用的对象在整个生命周期内永远不会被回收。

    2,软引用

    在内存不足,即抛出OutOfMemoryError前会被回收,可以和引用队列(ReferenceQueue)联合使用。

    3,弱引用

    只具有弱引用的对象,不管当前内存空间足够与否,都会被回收,可以和引用队列(ReferenceQueue)联合使用。

    4,虚引用

    任何时候都可能被回收,必须和引用队列(ReferenceQueue)联合使用,主要用来跟踪对象被垃圾回收器回收的活动

    二,四种类型详解

    1,强引用

    这是最常用的引用类型,我们平时声明的变量名都是强引用类型,Object o=new Object(),这里的o就是一个强引用类型,o所指向的对象,也就是new Object()操作后被分配在heap中的一块内存区域永远不会被回收,因为有强引用类型o来指向它。

    Question:被强引用的对象在整个程序声明周期内都不会被回收?

    Answer:当然不是,被强引用的对象也是会被回收的,有以下两种情况:

    1,主动切断对对象的强引用,即将引用赋值为nullObject o=new Object();o=null;,这样赋值为null后,在JVM进行gc时jiu会回收该对象,当然如果有多个强引用指向该对象,就需要都赋值为null,如下:

    Object o=new Object();
    Object o1=o;
    Object o2=o;
    //将引用o,o1,o2都赋值为null
    o=null;
    o1==null;
    o2=null;

    2,软引用

    如果一个对象具有软引用,内存空间足够,垃圾回收器就不会回收它;软可及对象的清理是由垃圾收集线程根据其特定算法按照内存需求决定的。

    “如果内存空间不足了,就会回收这些对象的内存。只要垃圾回收器没有回收它,该对象就可以被程序使用。“怎么理解这句话?看下面的例子:

    Object o=new Object();
    SoftReference sr=new SoftReference(o);
    o=null;
    Object oo=sr.get();

    这里的oo是一个强引用,也就是说,sr虽然是一个软引用,但却能get()一个强引用

    3,弱引用

    弱引用也是用来描述非必需对象的,当JVM进行垃圾回收时,无论内存是否充足,都会回收被弱引用关联的对象。在java中,用java.lang.ref.WeakReference类来表示。

    弱引用可以和一个引用队列(ReferenceQueue)联合使用,如果弱引用所引用的对象被JVM回收,这个软引用就会被加入到与之关联的引用队列中。

    ReferenceQueue<String> queue = new ReferenceQueue<String>();  
    WeakReference<String> pr = new WeakReference<String>(new String("hello"), queue);  

    4,虚引用

    虚引用和前面的软引用、弱引用不同,它并不影响对象的生命周期。在java中用java.lang.ref.PhantomReference类表示。如果一个对象与虚引用关联,则跟没有引用与之关联一样,在任何时候都可能被垃圾回收器回收。

    三,不同引用的应用

    1,用软引用和弱引用解决OOM问题

    2,软引用的get()再获取对象实现java对象告诉缓存

    3,弱引用保护敏感数据

    4,详见<https://www.cnblogs.com/huajiezh/p/5835618.html>

    转载于:https://www.cnblogs.com/Davidhwj/p/10595096.html

    展开全文
  • Java 四种引用类型

    2018-06-02 14:39:39
    Java 四种引用类型 1.强引用(StrongReference) 强引用是使用最普遍的引用。如果一个对象具有强引用,那垃圾回收器绝不会回收它。如下: Object o=new Object(); // 强引用 当内存空间不足,Java虚拟机...

    Java 四种引用类型

    1.强引用(StrongReference)

    强引用是使用最普遍的引用。如果一个对象具有强引用,那垃圾回收器绝不会回收它。如下:

      Object o=new Object();   //  强引用

    当内存空间不足,Java虚拟机宁愿抛出OutOfMemoryError错误,使程序异常终止,也不会靠随意回收具有强引用的对象来解决内存不足的问题。如果不使用时,要通过如下方式来弱化引用,如下:

      o=null;     // 帮助垃圾收集器回收此对象

    显式地设置o为null,或超出对象的生命周期范围,则gc认为该对象不存在引用,这时就可以回收这个对象。具体什么时候收集这要取决于gc的算法。

    强引用在实际中有非常重要的用处,举个ArrayList的实现源代码:

     private transient Object[] elementData;
    
     public void clear() {
    
        modCount++;
    
        // Let gc do its work
    
        for (int i = 0; i < size; i++)
    
            elementData[i] = null;
    
        size = 0;
    
          }

    在ArrayList类中定义了一个私有的变量elementData数组,在调用方法清空数组时可以看到为每个数组内容赋值为null。不同于elementData=null,强引用仍然存在,避免在后续调用 add()等方法添加元素时进行重新的内存分配。使用如clear()方法中释放内存的方法对数组中存放的引用类型特别适用,这样就可以及时释放内存。

    2.软引用(SoftReference)

    如果一个对象只具有软引用,则内存空间足够,垃圾回收器就不会回收它;如果内存空间不足了,就会回收这些对象的内存。只要垃圾回收器没有回收它,该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。

    String str=new String("abc");                                     // 强引用
    
    SoftReference<String> softRef=new SoftReference<String>(str);     // 软引用

    当内存不足时,等价于:

    If(JVM.内存不足()) {
    
      str = null;  // 转换为软引用
    
      System.gc(); // 垃圾回收器进行回收
    }

    虚引用在实际中有重要的应用,例如浏览器的后退按钮。按后退时,这个后退时显示的网页内容是重新进行请求还是从缓存中取出呢?这就要看具体的实现策略了。

    (1)如果一个网页在浏览结束时就进行内容的回收,则按后退查看前面浏览过的页面时,需要重新构建

    (2)如果将浏览过的网页存储到内存中会造成内存的大量浪费,甚至会造成内存溢出

    这时候就可以使用软引用

    Browser prev = new Browser();               // 获取页面进行浏览
    
    SoftReference sr = new SoftReference(prev); // 浏览完毕后置为软引用    
    
    if(sr.get()!=null){ 
    
    rev = (Browser) sr.get();           // 还没有被回收器回收,直接获取
    
    }else{
    
    prev = new Browser();               // 由于内存吃紧,所以对软引用的对象回收了
    
    sr = new SoftReference(prev);       // 重新构建
    
    }

    这样就很好的解决了实际的问题。

    软引用可以和一个引用队列(ReferenceQueue)联合使用,如果软引用所引用的对象被垃圾回收器回收,Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

    3.弱引用(WeakReference)

    弱引用与软引用的区别在于:只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中,一旦发现了只具有弱引用的对象,不管当前内存空间足够与否,都会回收它的内存。不过,由于垃圾回收器是一个优先级很低的线程,因此不一定会很快发现那些只具有弱引用的对象。

    String str=new String("abc");    
    WeakReference<String> abcWeakRef = new WeakReference<String>(str);
    
    str=null;

    当垃圾回收器进行扫描回收时等价于:

    str = null;
    
    System.gc();

    如果这个对象是偶尔的使用,并且希望在使用时随时就能获取到,但又不想影响此对象的垃圾收集,那么你应该用 Weak Reference 来记住此对象

    下面的代码会让str再次变为一个强引用:

    String  abc = abcWeakRef.get();

    弱引用可以和一个引用队列(ReferenceQueue)联合使用,如果弱引用所引用的对象被垃圾回收,Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

    当你想引用一个对象,但是这个对象有自己的生命周期,你不想介入这个对象的生命周期,这时候你就是用弱引用。

    这个引用不会在对象的垃圾回收判断中产生任何附加的影响

    4.虚引用(PhantomReference)

    “虚引用”顾名思义,就是形同虚设,与其他几种引用都不同,虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用,那么它就和没有任何引用一样,在任何时候都可能被垃圾回收器回收。

    虚引用主要用来跟踪对象被垃圾回收器回收的活动。虚引用与软引用和弱引用的一个区别在于:虚引用必须和引用队列(ReferenceQueue)联合使用。当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会在回收对象的内存之前,把这个虚引用加入到与之关联的引用队列中。

    展开全文
  • java四种引用类型

    万次阅读 2020-05-11 10:04:53
    编程语言都有自己操作内存中元素的方式,例如在 C 和 C++ 里是通过指针,而在 Java 中则是通过“引用”。 java不同于c/c++,它不需要程序员自已来管理内存(分配,释放内存),java 会自己来管理内存,比如销毁...

    背景:

    每种编程语言都有自己操作内存中元素的方式,例如在 C 和 C++ 里是通过指针,而在 Java 中则是通过“引用”。 java不同于c/c++,它不需要程序员自已来管理内存(分配,释放内存),java 会自己来管理内存,比如销毁某些不再被使用的对象。这些操作都是在一个后台线程默默进行(Garbage Collector Thread),也就是垃圾收集器线程,根据jvm实现的策略来释放对象内存。但是程序编写者却无法控制这个后台线程,无法让它在你想要的时候开始释放内存,销毁对象,按照你的规定来销毁那些对象,释放内存,这些都是都jvm自己控制的。但是随着 java.lang.ref这个包下的类的引进,程序员拥有了一点点控制你创建的对象何时释放,销毁的权利,当然只是一点点。

    四种引用类型

    在 JDK1.2 之前,Java中的定义很传统:如果 reference 类型的数据中存储的数值代表的是另外一块内存的起始地址,就称为这块内存代表着一个引用。

    Java 中的垃圾回收机制在判断是否回收某个对象的时候,都需要依据“引用”这个概念。

    但是,JDK1.2 之前,一个对象只有“已被引用”和"未被引用"两种状态,这将无法描述某些特殊情况下的对象,比如,当内存充足时需要保留,而内存紧张时才需要被抛弃的一类对象。

    所以在 JDK.1.2 之后,Java 对引用的概念进行了扩充,将引用分为了:强引用(Strong Reference)、软引用(Soft Reference)、弱引用(Weak Reference)、虚引用(Phantom Reference)4 种,这 4 种引用的强度依次减弱。

    强引用:

    只要强引用存在,垃圾回收器将永远不会回收被引用的对象,哪怕内存不足时,JVM也会直接抛出OutOfMemoryError,不会去回收。如果想中断强引用与对象之间的联系,可以显示的将强引用赋值为null,这样一来,JVM就可以适时的回收对象了(代码优化:某个大对象使用完后,如果后面的业务耗时久并且不会使用该对象,可以考虑赋值null)

    在 JDK1.2 之后,用java.lang.ref.FinalReference类来表示软引用。

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

     

    软引用:

    软引用是用来描述一些“还有用但是非必须”的对象。在内存足够的时候,软引用对象不会被回收,只有在内存不足时,系统则会回收软引用对象,如果回收了软引用对象之后仍然没有足够的内存,才会抛出内存溢出异常这种特性常常被用来实现缓存技术,比如网页缓存,图片缓存等。

    但实际上,软引用的回收策略在不同的JVM实现会略有不同,JVM不仅仅只会考虑当前内存情况,还会考虑软引用所指向的referent最近的使用情况和创建时间来综合决定是否回收该referent。软引用保存了两个变量:

    timestamp:每次调用get方法都会更新时间戳。JVM可以利用该字段来选择要清除的软引用,但不是必须要这样做。
    clock:时间锁,由垃圾收集器更新。
    因此,任何GC都可以使用这些字段并定义清除软引用的策略,例如:最后清除最近创建的或最近使用的软引用。

    在 JDK1.2 之后,用java.lang.ref.SoftReference类来表示软引用。

    /**
     * 软引用对象由垃圾收集器根据内存需要决定是否清除。软引用经常用于实现内存敏感的缓存。
     *
     * 假如垃圾收集器在某个时间确定对象是软可达的,此时它可以选择原子地清除
     * 指向该对象的所有软引用,以及从该对象通过强引用链连接的其他软可达对象的所有软引用。
     * 与时同时或者之后的某个时间,它会将注册了reference queues的新清除的软引用加入队列。
     *
     * 在虚拟机抛出OutOfMemoryError异常之前,将保证清除对软可达对象的所有软引用。
     * 不过,并没有对清除软引用的时间以及清除顺序施加强制约束。
     * 但是,鼓励虚拟机实现偏向不清除最近创建或最近使用的软引用。
     *
     * 该类的直接实例可用于实现简单的缓存。
     * 该类或其派生子类也可用于更大的数据结构以实现更复杂的高速缓存。
     * 只要软引用的引用对象还是强可达的,即还在实际使用中,软引用就不会被清除。
     * 因此,复杂的高速缓存可以通过持有对最近使用缓存对象的强引用来防止其被清除,
     * 而不常使用的剩余缓存对象由垃圾收集器决定是否清除。
     */
    public class SoftReference<T> extends Reference<T> {
    
    	// 时间锁,由垃圾收集器更新。
        static private long clock;
    
    	// 每次调用get方法都会更新该时间戳。JVM可能会在选择要清除的软引用时使用该字段,
    	// 但这不是强制必须的。
        private long timestamp;
    	
    	// 返回对象的引用。如果该引用对象已经被程序或者垃圾收集器清除,则返回null。
    	// 把最近一次垃圾回收时间赋值给timestamp
        public T get() {
            T o = super.get();
            if (o != null && this.timestamp != clock)
                this.timestamp = clock;
            return o;
        }
    
    }
    

    弱引用:

    弱引用的引用强度比软引用要更弱一些,无论内存是否足够,只要 JVM 开始进行垃圾回收,那些被弱引用关联的对象都会被回收

    当一个对象没有被强引用或者软引用连接,但被弱引用连接时,则处于弱可达状态。只要发生GC,弱可达的对象就会被清除,弱引用无法阻止自身被回收,同时会把弱引用加入到注册的引用队列中(如果存在的话)。弱引用对GC几乎是没有影响的,它不影响对应的referent被终结(finalized)和回收(reclaimed)。因此,弱引用最常用于实现规范化映射(canonicalizing mappings),例如哈希表,如果它们在程序中未被引用,则其键和值将从映射中删除。

    在 JDK1.2 之后,用 java.lang.ref.WeakReference 来表示弱引用。

    /**
     * 弱引用对象不能阻止自身的引用被回收。
     * 弱引用常用于实现规范化映射(对象实例可以在程序的多个地方同时使用)。
     *
     * 假如垃圾收集器在某个时间点确定对象是弱可达的。那时它将原子地清除对该对象的所有弱引用
     * 以及该引用通过强引用或者软引用连接的所有其他弱可达对象的所有弱引用。
     * 同时,它将表明前面所指的所有弱可达对象都可以执行finalize方法。
     * 与此同时或之后某一个时间,它将注册了reference queues的那些新清除弱引用加入队列。
     */
    public class WeakReference<T> extends Reference<T> {
    
    	// 创建没有注册ReferenceQueue的弱引用
        public WeakReference(T referent) {
            super(referent);
        }
    
    	// 创建注册了ReferenceQueue的弱引用
        public WeakReference(T referent, ReferenceQueue<? super T> q) {
            super(referent, q);
        }
    }
    

    虚引用:

    虚引用是所有引用类型中最弱的一种。一个对象是否关联到虚引用,完全不会影响该对象的生命周期,也无法通过虚引用来获取一个对象的实例。虚引用和弱引用的回收机制差不多,都是可以被随时回收的。

    为对象设置一个虚引用的唯一目的是:它的构造方法必须强制传入ReferenceQueue,因为在jvm回收前(重点:软引用和弱引用都是回收后)JVM自动把虚引用对象本身(PhantomReference对象)加入到ReferenceQueue中,表明该reference指向的referent被回收。然后可以通过去queue中取到reference,可以通过这个来做额外的清理工作。可以用虚引用代替对象finalize方法来实现资源释放,这样更加灵活和安全。还有一点就是PhantomReference.get()方法永远返回空,不管对象有没有被回收。

    在 JDK1.2 之后,用 java.lang.ref.PhantomReference 来表示弱引用。

    /**
     * 虚引用对象在被垃圾收集器检查到后加入reference queues队列,否则会被回收。
     * 虚引用最常用于实现比Java finalization机制更灵活的安排额外的清理工作。
     *
     * 如果垃圾收集器在某个时间点确定虚引用对象是虚可达的,那么在那个时间或之后某个时间它会将引用加入reference queues队列。
     *
     * 为了确保可回收对象保持不变,虚引用的引用无法使用:虚引用对象的get方法始终返回null。
     *
     * 与软引用和弱引用不同,当虚引用加入reference queues队列后垃圾收集器不会被自动清除。
     * 只通过虚引用可达的对象将保持不变,直到所有此类引用都被清除或自已变为不可达。
     */
    public class PhantomReference<T> extends Reference<T> {
    
        // 由于不能通过虚引用访问对象,因此此方法始终返回null。
        public T get() {
            return null;
        }
    
        // 使用空ReferenceQueue队列创建一个虚引用没有意义:它的get方法总是返回null,
    	// 并且由于它没有注册队列,所以也不会被加入队列有任何清理前的预处理操作。
        public PhantomReference(T referent, ReferenceQueue<? super T> q) {
            super(referent, q);
        }
    }
    

     

    展开全文
  • Java四种引用类型

    2016-03-10 16:05:00
    Java四种引用类型,strongreference,softreference,weakreference,phantomreference。这四种引用的强度按照上面的顺序依次减弱,下面通过几个例子简单了解一下这四种引用类型。 StrongReference 这个不用多讲了...
  • java 四种引用类型

    2020-03-29 21:30:42
    Java 中常见的就是强引用,把一个对象赋给一个引用变量, 这个引用变量就是一个强引用。当一个对象被强引用变量引用时, 它处于可达状态,它是不可能被垃圾回收机制回收的,即使该对 象以后永远都不会被用到JVM也...
  • JAVA 四种引用类型

    2020-03-05 17:35:35
    Java 中最常见的就是强引用,把一个对象赋给一个引用变量,这个引用变量就是一个强引 用。当一个对象被强引用变量引用时,它处于可达状态,它是不可能被垃圾回收机制回收的,即 使该对象以后永远都不会被用到 JVM...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,009
精华内容 1,203
关键字:

java四种引用类型

java 订阅