Java查漏补缺——四种引用

今天复习到一种没看到过的Java知识点，是关于内存不足时Java对象的建立的。

引用

　　Java对每一个对象的使用被称为Java的引用，类似于C和C++的指针，引用则是调用对象和对象方法时的称呼。

String s = new String();

　　这就是一种引用（强引用）。

　　不难看出，这只是创建了一个String类型的对象s，但是这确实是一种强引用。（用C语言指针解释的话，就是s指向了一个String对象）

四种引用

• 强引用

  • • 上面讲的没有任何修饰的直接调用就是强引用，强引用的对象直接建立在jvm内存空间的栈空间中，需要的时候直接调用其成员。此时就会出现问题，内存空间不足的时候，对象无法建立成功，那么就会直接报“对象创立失败，内存不足”的错误。

• 软引用

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

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

      下面以一个例子来进一步说明强引用和软引用的区别：
      在运行下面的Java代码之前，需要先配置参数 -Xms2M -Xmx3M，将 JVM 的初始内存设为2M，最大可用内存为 3M。

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

      public class TestOOM {
          
          public static void main(String[] args) {
               testStrongReference();
          }
          private static void testStrongReference() {
              // 当 new byte为 1M 时，程序运行正常
              byte[] buff = new byte[1024 * 1024 * 1];
          }
      }

       

      但是如果我们将

      byte[] buff = new byte[1024 * 1024 * 1];
      

      替换为创建一个大小为 2M 的字节数组

      byte[] buff = new byte[1024 * 1024 * 2];
      

      则内存不够使用，程序直接报错，强引用并不会被回收
      

      接着来看一下软引用会有什么不一样，在下面的示例中连续创建了 10 个大小为 1M 的字节数组，并赋值给了软引用，然后循环遍历将这些对象打印出来。

      public class TestOOM {
          private static List<Object> list = new ArrayList<>();
          public static void main(String[] args) {
               testSoftReference();
          }
          private static void testSoftReference() {
              for (int i = 0; i < 10; i++) {
                  byte[] buff = new byte[1024 * 1024];
                  SoftReference<byte[]> sr = new SoftReference<>(buff);
                  list.add(sr);
              }
              
              System.gc(); //主动通知垃圾回收
              
              for(int i=0; i < list.size(); i++){
                  Object obj = ((SoftReference) list.get(i)).get();
                  System.out.println(obj);
              }
              
          }
          
      }

       

      打印结果：
      

      我们发现无论循环创建多少个软引用对象，打印结果总是只有最后一个对象被保留，其他的obj全都被置空回收了。
      这里就说明了在内存不足的情况下，软引用将会被自动回收。
      值得注意的一点 , 即使有 byte[] buff 引用指向对象, 且 buff 是一个strong reference, 但是 SoftReference sr 指向的对象仍然被回收了，这是因为Java的编译器发现了在之后的代码中, buff 已经没有被使用了, 所以自动进行了优化。
      如果我们将上面示例稍微修改一下：

          private static void testSoftReference() {
              byte[] buff = null;
      
              for (int i = 0; i < 10; i++) {
                  buff = new byte[1024 * 1024];
                  SoftReference<byte[]> sr = new SoftReference<>(buff);
                  list.add(sr);
              }
      
              System.gc(); //主动通知垃圾回收
              
              for(int i=0; i < list.size(); i++){
                  Object obj = ((SoftReference) list.get(i)).get();
                  System.out.println(obj);
              }
      
              System.out.println("buff: " + buff.toString());
          }

       

      则 buff 会因为强引用的存在，而无法被垃圾回收，从而抛出OOM的错误。
      

      如果一个对象惟一剩下的引用是软引用，那么该对象是软可及的（softly reachable）。垃圾收集器并不像其收集弱可及的对象一样尽量地收集软可及的对象，相反，它只在真正 “需要” 内存时才收集软可及的对象。

• 弱引用

  • • 弱引用的引用强度比软引用要更弱一些，无论内存是否足够，只要 JVM 开始进行垃圾回收，那些被弱引用关联的对象都会被回收。在 JDK1.2 之后，用 java.lang.ref.WeakReference 来表示弱引用。
      我们以与软引用同样的方式来测试一下弱引用：

      private static void testWeakReference() {
              for (int i = 0; i < 10; i++) {
                  byte[] buff = new byte[1024 * 1024];
                  WeakReference<byte[]> sr = new WeakReference<>(buff);
                  list.add(sr);
              }
              
              System.gc(); //主动通知垃圾回收
              
              for(int i=0; i < list.size(); i++){
                  Object obj = ((WeakReference) list.get(i)).get();
                  System.out.println(obj);
              }
          }

       

      打印结果：
      

      可以发现所有被弱引用关联的对象都被垃圾回收了。

• 虚引用

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

      public class PhantomReference<T> extends Reference<T> {
          /**
           * 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;
          }
          public PhantomReference(T referent, ReferenceQueue<? super T> q) {
              super(referent, q);
          }
      }