【Java基础】面试官:谈一谈你对Java中四种引用类型的理解?

文章目录

  • 一、前言
  • 二、强引用
  • 三、软引用
  • 四、弱引用
  • 五、虚引用
  • 六、面试金手指(背下来)
      • 谈一谈你对Java中四种引用类型的理解?
  • 七、小结

一、前言

Java两种数据类型:8种值类型和3种引用类型(类、接口、数组),不管哪种引用类型,都要有相应的引用。

在Java中提供了四个级别的引用:强引用,软引用,弱引用和虚引用。在这四个引用类型中,只有强引用FinalReference类是包内可见,其他三种引用类型均为public,可以在应用程序中直接使用。引用类型的类结构如图所示。

【Java基础】面试官:谈一谈你对Java中四种引用类型的理解?_第1张图片

【Java基础】面试官:谈一谈你对Java中四种引用类型的理解?_第2张图片
【Java基础】面试官:谈一谈你对Java中四种引用类型的理解?_第3张图片
【Java基础】面试官:谈一谈你对Java中四种引用类型的理解?_第4张图片
【Java基础】面试官:谈一谈你对Java中四种引用类型的理解?_第5张图片

金手指1:四种引用类型都是继承Reference抽象类,其中,只有强引用FinalReference类是包内可见,其他三种引用类型均为public

二、强引用

Java中默认声明的就是强引用,例如以下代码,如果M对象被回收了,会打印finalize()方法中的内容:

public class Demo {
    public static void main(String[] args) throws IOException {
        M m = new M();  //只要m还指向M对象,M对象就不会被回收
        // m = null;   //手动置null
        System.gc();  // 进行垃圾回收

        System.in.read();
    }
}

class M {
    @Override
    protected void finalize() {
        System.out.println("对象被回收了...");
    }
}

运行结果:

【Java基础】面试官:谈一谈你对Java中四种引用类型的理解?_第6张图片

只要强引用存在,垃圾收集器将永远不会回收被引用的对象,哪怕内存不足时,JVM也会直接抛出OutOfMemoryError,不会去回收。如果想中断强引用与对象之间的联系,可以显示的将强引用赋值为null,这样一来,JVM就可以适时的回收对象了。例如上面的代码,将 m = null; 注释放开时,运行结果如下:

【Java基础】面试官:谈一谈你对Java中四种引用类型的理解?_第7张图片

三、软引用

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

在 JDK1.2 之后,用 SoftReference 类来表示软引用。下面以一个例子来进一步说明强引用和软引用的区别。

在运行下面的Java代码之前,需要先配置参数 -Xms2M -Xmx2M,将 JVM 的初始内存设为2M,最大可用内存为 2M。

首先先来测试一下强引用,在限制了 JVM 内存的前提下,下面的代码运行正常

public class Demo {
    public static void main(String[] args) {
        // 当 new byte为 1M 时,程序运行正常
        byte[] buff1 = new byte[1024 * 1024 * 1];
        
        // byte[] buff2 = new byte[1024 * 1024 * 1];
    }
}

但是如果我们再创建一个1M大小的 byte数组时,则内存不够使用,程序直接报错。因为强引用不会被回收。

【Java基础】面试官:谈一谈你对Java中四种引用类型的理解?_第8张图片

接着来看一下软引用会有什么不一样,在下面的示例中先创建一个大小为 1M 的软引用对象,打印m的地址,然后进行垃圾回收,休眠500ms后打印m的地址。最后又创建了一个1M的字节数组,打印m的地址。

public class Demo {
    public static void main(String[] args) {
        SoftReference<byte[]> m = new SoftReference<>(new byte[1024 * 1024]);

        System.out.println(m.get());
        System.gc();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(m.get());
        // 再分配一个数组,heap将装不下,
        // 这时系统会进行垃圾回收,如果内存不够,会把软引用干掉
        byte[] b = new byte[1024*1024*1];
        System.out.println(m.get());
    }
}

运行结果:

【Java基础】面试官:谈一谈你对Java中四种引用类型的理解?_第9张图片

根据运行结果,我们可以看到,在内存不足的情况下,软引用才会被回收。

四、弱引用

弱引用的引用强度比软引用要更弱一些,无论内存是否足够,只要 JVM 开始进行垃圾回收,那些被弱引用关联的对象都会被回收。在 JDK1.2 之后,用 WeakReference 来表示弱引用。

我们以与软引用同样的方式来测试一下弱引用:

public class Demo {
    public static void main(String[] args) {
        WeakReference<byte[]> m = new WeakReference<>(new byte[1024 * 1024]);

        System.out.println(m.get());
        System.gc();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(m.get());
    }
}

运行结果:

【Java基础】面试官:谈一谈你对Java中四种引用类型的理解?_第10张图片

根据运行结果,可以发现垃圾回收后被弱引用关联的对象被回收了。

在 Java 集合中有一种特殊的 Map 类型:WeakHashMap, 在这种 Map 中存放了键对象的弱引用,当一个键对象被垃圾回收,那么相应的值对象的引用会从 Map 中删除。WeakHashMap 能够节约存储空间,可用来缓存那些非必须存在的数据。

五、虚引用

虚引用是最弱的一种引用关系,如果一个对象仅持有虚引用,那么它就和没有任何引用一样,它随时可能会被回收。在 JDK1.2 之后,用 PhantomReference 类来表示,通过查看这个类的源码,发现它只有一个构造函数和一个 get() 方法,而且它的 get() 方法仅仅是返回一个null,也就是说将永远无法通过虚引用来获取对象。虚引用必须要和 ReferenceQueue 引用队列一起使用。

public class PhantomReference<T> extends Reference<T> {
    public T get() {
        return null;
    }

    public PhantomReference(T referent, ReferenceQueue<? super T> q) {
        super(referent, q);
    }
}
public class Demo {

    private static final List<Object> LIST = new LinkedList<>();
    private static final ReferenceQueue QUEUE = new ReferenceQueue();

    public static void main(String[] args) {
        PhantomReference<M> m = new PhantomReference<>(new M(), QUEUE);

        new Thread(()->{
            while (true) {
                LIST.add(new byte[1024*1024]);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    Thread.currentThread().interrupt();
                }
                System.out.println(m.get());
            }
        }).start();

        new Thread(()->{
            while (true) {
                Reference poll = QUEUE.poll();
                if(poll != null) {
                    System.out.println("虚引用对象:" + poll + " 被jvm回收了");
                }
            }
        }).start();
    }
}

class M {
    @Override
    protected void finalize() {
        System.out.println("对象被回收了...");
    }
}

运行结果:

【Java基础】面试官:谈一谈你对Java中四种引用类型的理解?_第11张图片

当垃圾回收器准备回收一个对象时,如果发现它还有引用,那么就会在回收对象之前,把这个引用加入到与之关联的引用队列中去。主要用于清理堆外内存。

六、面试金手指(背下来)

谈一谈你对Java中四种引用类型的理解?

金手指1:四种引用类型都是继承Reference抽象类,其中,只有强引用FinalReference类是包内可见,其他三种引用类型均为public

强引用FinalReference 软引用SoftReference 弱引用WeakReferece 虚引用PhantomReference
什么时候释放 两个条件(System.gc()/自动内存回收+内存不够)同时满足也不释放,永远都不会释放,内存不够就OOM,不释放,除非将引用设置为null,System.gc()才释放 两个条件:System.gc()/自动内存回收+内存不够,同时满足,回收 一个条件: System.gc()/自动内存回收,回收 无条件:任意时候都可以回收
作用 程序员写代码都是使用强引用,引用只要设置为null,System.gc()和自动垃圾都无法回收,保证程序绝对可靠运行,内存不够就OOM异常 作用:缓存技术,比如网页缓存,图片缓存,如果内存不够,就清空缓存保护内存(总不能因为缓存把程序OOM吧,程序OOM只有一个原因,那就是强引用,而强引用是程序员可以把握的,所有OOM是程序员可以处理的) WeakHashMap 节约存储空间,作为缓存一些不重要的数据 好像没啥作用

优先级:
强引用 > 内存不够OOM > 软引用 > 弱引用 >虚引用

1、强引用的优先级比OOM高:程序员写代码都是使用强引用,引用只要设置为null,System.gc()和自动垃圾都无法回收,保证程序绝对可靠运行,内存不够就OOM异常
2、软引用的优先级比OOM低:作用:缓存技术,比如网页缓存,图片缓存,如果内存不够,就清空缓存保护内存(总不能因为缓存把程序OOM吧,程序OOM只有一个原因,那就是强引用,而强引用是程序员可以把握的,所有OOM是程序员可以处理的)

七、小结

Java四种引用,完成了。

天天打码,天天进步!!!

你可能感兴趣的:(【Java基础】面试官:谈一谈你对Java中四种引用类型的理解?)