6. 强引用

6.1 概念

  • 我们希望能描述这样一类对象:当内存空间还足够时,则能保留在内存中;如果内存空间在进行垃圾收集后还是很紧张,则可以抛弃这些对象。
  • 既偏门又非常高频的面试题：强引用、软引用、弱引用、虚引用有什么区别?具体使用场景是什么?
  • 在JDK1.2版之后,Java对引用的概念进行了扩充,将引用分为强引用( Strong Reference)、软引用( Soft Reference)、弱引用( Weak Reference)和虚引用( Phantom Reference)4种,这4种引用强度依次逐渐减弱。
  • 除强引用外,其他3种引用均可以在java.lang.ref包中找到它们的身影。如下图,显示了这3种引用类型对应的类,开发人员可以在应用程序中直接使用它们。

image.png
Reference子类中只有终结器引用是包内可见的,其他3种引用类型均为public,可以在应用程序中直接使用

  • 强引用( Strong Reference): 最传统的“引用”的定义,是指在程序代码之中普遍存在的引用赋值,即类似“0 bject obj= new Object()”这种引用关系。无论任何情况下,只要强引用关系还存在,垃圾收集器就永远不会回收掉被引用的对象。
  • 软引用( Soft Reference): 在系统将要发生内存溢出之前,将会把这些对象列入回收范围之中进行第二次回收。如果这次回收后还没有足够的内存,才会抛出内存溢出异常。
  • 弱引用( Weak Reference): 被弱引用关联的对象只能生存到下一次垃圾收集之前。当垃圾收集器工作时,无论内存空间是否足够,都会回收掉被弱引用关联的对象。

  • 虚引用( Phantom Reference): 一个对象是否有虚引用的存在,完全不会对其生存时间构成影响,也无法通过虚引用来获得一个对象的实例。为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知。

    6.2 不回收

  • 在Java程序中,最常见的引用类型是强引用(普通系统99%以上都是强引用),也就是我们最常见的普通对象引用,也是默认的引用类型。

  • 当在Java语言中使用new操作符创建一个新的对象,并将其赋值给一个变量的时候,这个变量就成为指向该对象的一个强引用。
  • 强引用的对象是可触及的,垃圾收集器就永远不会回收掉被引用的对象。
  • 对于一个普通的对象,如果没有其他的引用关系,只要超过了引用的作用域或者显式地将相应(强)引用赋值为null,就是可以当做垃圾被收集了,当然具体回收时机还是要看垃圾收集策略。
  • 相对的,软引用、弱引用和虚引用的对象是软可触及、弱可触及和虚可触及的,在定条件下,都是可以被回收的。所以,强引用是造成Java内存泄漏的主要原因之一。

强引用例子：

  1. /**
  2.  *  强引用的测试
  3.  * @create 2020  16:05
  4.  */
  5. public class StrongReferenceTest {
  6.     public static void main(String[] args) {
  7.         StringBuffer str = new StringBuffer ("Hello");
  8.         StringBuffer str1 = str;
  10.         str = null;
  11.         System.gc();
  13.         try {
  14.             Thread.sleep(3000);
  15.         } catch (InterruptedException e) {
  16.             e.printStackTrace();
  17.         }
  19.         System.out.println(str1);
  20.     }
  21. }

StringBuffer str = new StringBuffer(“Hello”);
局部变量str指向 Stringbuffer实例所在堆空间,通过str可以操作该实例,那么str就是 Stringbuffer实例的强引用。
对应内存结构:
image.png

6.3 特点

  • 强引用可以直接访问目标对象。
  • 强引用所指向的对象在任何时候都不会被系统回收,虚拟机宁愿抛出OOM异常,也不会回收强引用所指向对象。

  • 强引用可能导致内存泄漏。

    7. 再谈引用：软引用

    7.1 内存不足既回收

  • 软引用是用来描述一些还有用,但非必需的对象。只被软引用关联着的对象在系统将要发生内存溢出异常前,会把这些对象列进回收范围之中进行第次回收,如果这次回收还没有足够的内存,才会抛出内存溢出异常。

  • 软引用通常用来实现内存敏感的缓存。比如:高速缓存就有用到软引用。如果还有空闲内存,就可以暂时保留缓存,当内存不足时清理掉,这样就保证了使用缓存的同时,不会耗尽内存。
  • 垃圾回收器在某个时刻决定回收软可达的对象的时候,会清理软引用,并可选地把引用存放到一个引用队列( Reference Queue)。
  • 类似弱引用,只不过Java虚拟机会尽量让软引用的存活时间长一些,迫不得已才清理。

image.png

7.2 例子

  1. import java.lang.ref.SoftReference;
  2. /**
  3.  * 软引用的测试：内存不足即回收
  4.  * -Xms10m -Xmx10m -XX:+PrintGCDetails
  5.  * @create 2020  16:06
  6.  */
  7. public class SoftReferenceTest {
  8.     public static class User {
  9.         public User(int id, String name) {
  10.             this.id = id;
  11.             this.name = name;
  12.         }
  14.         public int id;
  15.         public String name;
  17.         @Override
  18.         public String toString() {
  19.             return "[id=" + id + ", name=" + name + "] ";
  20.         }
  21.     }
  23.     public static void main(String[] args) {
  24.         //创建对象，建立软引用
  25. //        SoftReference<User> userSoftRef = new SoftReference<User>(new User(1, "songhk"));
  26.         //上面的一行代码，等价于如下的三行代码
  27.         User u1 = new User(1,"songhk");
  28.         SoftReference<User> userSoftRef = new SoftReference<User>(u1);
  29.         u1 = null;//取消强引用
  32.         //从软引用中重新获得强引用对象
  33.         System.out.println(userSoftRef.get());
  35.         System.gc();//触发full gc
  36.         System.out.println("After GC:");
  37. //        //垃圾回收之后获得软引用中的对象
  38.         System.out.println(userSoftRef.get());//由于堆空间内存足够，所有不会回收软引用的可达对象。
  39. //
  40.         try {
  41.             //让系统认为内存资源紧张、不够
  42.             byte[] b = new byte[7168 * 1024];
  43.         } catch (Throwable e) {
  44.             e.printStackTrace();
  45.         } finally {
  46.             //再次从软引用中获取数据
  47.             System.out.println(userSoftRef.get());//在报OOM之前，垃圾回收器会回收软引用的可达对象。
  48.         }
  49.     }
  50. }

8. 弱引用

8.1 概念

  • 弱引用也是用来描述那些非必需对象,被弱引用关联的对象只能生存到下一次垃圾收集发生为止。在系统GC时,只要发现弱引用,不管系统堆空间使用是否充足,都会回收掉只被弱引用关联的对象。
  • 但是,由于垃圾回收器的线程通常优先级很低,因此,并不一定能很快地发现持有弱引用的对象。在这种情况下,弱引用对象可以存在较长的时间。
  • 弱引用和软引用一样,在构造弱引用时,也可以指定一个引用队列,当弱引用对象被回收时,就会加入指定的引用队列,通过这个队列可以跟踪对象的回收情况。
  • 软引用、弱引用都非常适合来保存那些可有可无的缓存数据。如果这么做,当系统内存不足时,这些缓存数据会被回收,不会导致内存溢出。而当内存资源充足时,这些缓存数据又可以存在相当长的时间,从而起到加速系统的作用。

    8.2 发现即回收

    在JDK1.2版之后提供了java.lang.ref. WeakReference类来实现弱引用。
    image.png
    弱引用对象与软引用对象的最大不同就在于,当GC在进行回收时,需要通过算法检査是否回收软引用对象,而对于弱引用对象,GC总是进行回收。弱引用对象更容易、更快被GC回收。
    面试题:你开发中使用过 WeakHashMap吗?

    8.3 代码例子

    ```java import java.lang.ref.WeakReference;

/**

  • 弱引用的测试

  • @create 2020 16:06 */ public class WeakReferenceTest { public static class User {

    1.  public User(int id, String name) {
    2.      this.id = id;
    3.      this.name = name;
    4.  }
    6.  public int id;
    7.  public String name;
    9.  @Override
    10.  public String toString() {
    11.      return "[id=" + id + ", name=" + name + "] ";
    12.  }

    }

    public static void main(String[] args) {

    1.  //构造了弱引用
    2.  WeakReference<User> userWeakRef = new WeakReference<User>(new User(1, "songhk"));
    3.  //从弱引用中重新获取对象
    4.  System.out.println(userWeakRef.get());
    6.  System.gc();
    7.  // 不管当前内存空间足够与否，都会回收它的内存
    8.  System.out.println("After GC:");
    9.  //重新尝试从弱引用中获取对象
    10.  System.out.println(userWeakRef.get());

    } } ``` image.png

    9. 虚引用

    9.1 概念(对象回收跟踪)

  • 也称为“幽灵引用”或者“幻影引用”,是所有引用类型中最弱的一个。
  • 一个对象是否有虚引用的存在,完全不会决定对象的生命周期。如果一个对象仅持有虚引用,那么它和没有引用几乎是一样的,随时都可能被垃圾回收器回收。
  • 它不能单独使用,也无法通过虚引用来获取被引用的对象。当试图通过虚引用的get()方法取得对象时,总是null。
  • 为一个对象设置虚引用关联的唯一目的在于跟踪垃圾回收过程。比如:能在这个对象被收集器回收时收到一个系统通知。
  • 虚引用必须和引用队列一起使用。虚引用在创建时必须提供一个引用队列作为参数。当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会在回收对象后,将这个虚引用加入引用队列,以通知应用程序对象的回收情况。
  • 由于虚引用可以跟踪对象的回收时间,因此,也可以将一些资源释放操作放置在虚引用中执行和记录。
  • 在JDK1.2版之后提供了 Phantom Reference类来实现虚引用。

    9.2 举例

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

/**

  • 虚引用的测试 *
  • @author shkstart shkstart@126.com

  • @create 2020 16:07 */ public class PhantomReferenceTest { public static PhantomReferenceTest obj;//当前类对象的声明 static ReferenceQueue phantomQueue = null;//引用队列

    public static class CheckRefQueue extends Thread {

    1.  @Override
    2.  public void run() {
    3.      while (true) {
    4.          if (phantomQueue != null) {
    5.              PhantomReference<PhantomReferenceTest> objt = null;
    6.              try {
    7.                  objt = (PhantomReference<PhantomReferenceTest>) phantomQueue.remove();
    8.              } catch (InterruptedException e) {
    9.                  e.printStackTrace();
    10.              }
    11.              if (objt != null) {
    12.                  System.out.println("追踪垃圾回收过程：PhantomReferenceTest实例被GC了");
    13.              }
    14.          }
    15.      }
    16.  }

    }

    @Override protected void finalize() throws Throwable { //finalize()方法只能被调用一次！

    1.  super.finalize();
    2.  System.out.println("调用当前类的finalize()方法");
    3.  obj = this;

    }

    public static void main(String[] args) {

    1.  Thread t = new CheckRefQueue();
    2.  t.setDaemon(true);//设置为守护线程：当程序中没有非守护线程时，守护线程也就执行结束。
    3.  t.start();
    5.  phantomQueue = new ReferenceQueue<PhantomReferenceTest>();
    6.  obj = new PhantomReferenceTest();
    7.  //构造了 PhantomReferenceTest 对象的虚引用，并指定了引用队列
    8.  PhantomReference<PhantomReferenceTest> phantomRef = new PhantomReference<PhantomReferenceTest>(obj, phantomQueue);
    10.  try {
    11.      //不可获取虚引用中的对象
    12.      System.out.println(phantomRef.get());
    14.      //将强引用去除
    15.      obj = null;
    16.      //第一次进行GC,由于对象可复活，GC无法回收该对象
    17.      System.gc();
    18.      Thread.sleep(1000);
    19.      if (obj == null) {
    20.          System.out.println("obj 是 null");
    21.      } else {
    22.          System.out.println("obj 可用");
    23.      }
    24.      System.out.println("第 2 次 gc");
    25.      obj = null;
    26.      System.gc(); //一旦将obj对象回收，就会将此虚引用存放到引用队列中。
    27.      Thread.sleep(1000);
    28.      if (obj == null) {
    29.          System.out.println("obj 是 null");
    30.      } else {
    31.          System.out.println("obj 可用");
    32.      }
    33.  } catch (InterruptedException e) {
    34.      e.printStackTrace();
    35.  }

    } } ```

    10. 终结器引用

  • 它用以实现对象的finalize()方法,也可以称为终结器引用。
  • 无需手动编码,其内部配合引用队列使用。
  • 在GC时,终结器引用入队。由 Finalizer线程通过终结器引用找到被引用对象并调用它的 finalize()方法,第二次GC时才能回收被引用对象。