JVM 基础 (2) -- Java 中的四种引用

最新推荐文章于 2021-12-20 08:27:08 发布

南京.

最新推荐文章于 2021-12-20 08:27:08 发布

阅读量86

点赞数

分类专栏： # JVM 基础

本文链接：https://blog.csdn.net/qq_38350925/article/details/104938321

版权

JVM 基础专栏收录该内容

10 篇文章 1 订阅

订阅专栏

文章目录

1. 强引用

强引用就是指在程序代码之中普遍存在的，类似 Object obj = new Object() 这类的引用，只要强引用还存在，垃圾收集器永远不会回收掉被引用的对象，可以通过手动设置 obj = null； 来断开强引用

public class StrongReferenceTest {

   public static int M = 1024*1024;
   
   public static void printlnMemory(String tag){
       Runtime runtime = Runtime.getRuntime();
       int M = StrongReferenceTest.M;
       System.out.println("\n"+tag+":");
       System.out.println(runtime.freeMemory()/M+"M(free)/" + runtime.totalMemory()/M+"M(total)");
   }

   public static void main(String[] args){
       StrongReferenceTest.printlnMemory("1.原可用内存和总内存");

       //实例化10M的数组并与strongReference建立强引用
       byte[] strongReference = new byte[10*StrongReferenceTest.M];
       StrongReferenceTest.printlnMemory("2.实例化10M的数组,并建立强引用");
       System.out.println("strongReference : "+strongReference);

       System.gc();
       StrongReferenceTest.printlnMemory("3.GC后");
       System.out.println("strongReference : "+strongReference);

       //strongReference = null;后,强引用断开了
       strongReference = null;
       StrongReferenceTest.printlnMemory("4.强引用断开后");
       System.out.println("strongReference : "+strongReference);

       System.gc();
       StrongReferenceTest.printlnMemory("5.GC后");
       System.out.println("strongReference : "+strongReference);
   }
}

在这里插入图片描述

2. 软引用

软引用是用来描述一些还有用但并非必需的对象，对于软引用关联着的对象，在系统将要发生内存溢出异常之前，将会把这些对象列入回收范围进行第二次回收。如果这次回收还没有足够的内存，才会抛出内存溢出异常。在JDK1.2 之后，提供了 SoftReference 类来实现软引用。
软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收，Java 虚拟机就会把这个软引用加入到与之关联的引用队列中

Object obj = new Object();
SoftReference<Object> sf = new SoftReference<Object>(obj);

public class SoftReferenceTest {

   public static int M = 1024*1024;

   public static void printlnMemory(String tag){
       Runtime runtime = Runtime.getRuntime();
       int M = StrongReferenceTest.M;
       System.out.println("\n"+tag+":");
       System.out.println(runtime.freeMemory()/M+"M(free)/" + runtime.totalMemory()/M+"M(total)");
   }

   public static void main(String[] args){
       SoftReferenceTest.printlnMemory("1.原可用内存和总内存");

       //建立软引用
       SoftReference<Object> softRerference = new SoftReference<Object>(new byte[10*SoftReferenceTest.M]);
       SoftReferenceTest.printlnMemory("2.实例化10M的数组,并建立软引用");
       System.out.println("softRerference.get() : "+softRerference.get());

       System.gc();  
       SoftReferenceTest.printlnMemory("3.内存可用容量充足，GC后");
       System.out.println("softRerference.get() : "+softRerference.get());  

       //实例化一个4M的数组,使内存不够用,并建立软引用
       //free=10M=4M+10M-4M,证明内存可用量不足时，GC后byte[10*m]被回收
       SoftReference<Object> softRerference2 = new SoftReference<Object>(new byte[4*SoftReferenceTest.M]);
       SoftReferenceTest.printlnMemory("4.实例化一个4M的数组后");
       System.out.println("softRerference.get() : "+softRerference.get());
       System.out.println("softRerference2.get() : "+softRerference2.get());  
   } 
}

在这里插入图片描述

3. 弱引用

弱引用也是用来描述非必需对象的，但是它的强度比软引用更弱一些，被弱引用关联的对象，只能生存到下一次垃圾收集发生之前。当垃圾收集器工作时，无论当前内存是否足够，都会回收掉只被弱引用关联的对象。在 JDK1.2 之后，提供了 WeakReference 类来实现弱引用
弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java 虚拟机就会把这个弱引用加入到与之关联的引用队列中

Object obj = new Object();
WeakReference<Object> wf = new WeakReference<Object>(obj);

public class WeakReferenceTest {

   public static int M = 1024*1024;

   public static void printlnMemory(String tag){
       Runtime runtime = Runtime.getRuntime();
       int M = WeakReferenceTest.M;
       System.out.println("\n"+tag+":");
       System.out.println(runtime.freeMemory()/M+"M(free)/" + runtime.totalMemory()/M+"M(total)");
   }

   public static void main(String[] args){  
       WeakReferenceTest.printlnMemory("1.原可用内存和总内存");

       //创建弱引用
       WeakReference weakRerference = new WeakReference(new byte[10*WeakReferenceTest.M]);   
       WeakReferenceTest.printlnMemory("2.实例化10M的数组,并建立弱引用");
       System.out.println("weakRerference.get() : "+weakRerference.get());

       System.gc();
       StrongReferenceTest.printlnMemory("3.GC后");
       System.out.println("weakRerference.get() : "+weakRerference.get());
   }   
}

在这里插入图片描述

4. 虚引用

虚引用也称为幽灵引用或幻影引用，它是最弱的一种引用关系。从 PhantomReference 类的源代码可以知道，它的 get() 方法无论何时返回的都只会是 null。一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来取得一个对象实例。为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知（可用来在对象被回收时做额外的一些资源清理或事务回滚等处理）。在 JDK1.2 之后，提供给了 PhantomReference 类来实现虚引用
虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。
特别注意，在程序设计中一般很少使用弱引用与虚引用，使用软引用的情况较多，这是因为软引用可以加速 JVM 对垃圾内存的回收速度，可以维护系统的运行安全，防止内存溢出（OutOfMemory）等问题的产生

Object obj = new Object();
ReferenceQueue<Object> referenceQueue = new ReferenceQueue<Object>();
PhantomReference<Object> pf = new PhantomReference<Object>(obj，referenceQueue);

public class PhantomReferenceTest {

   public static int M = 1024*1024;

   public static void printlnMemory(String tag){
       Runtime runtime = Runtime.getRuntime();
       int M = PhantomReferenceTest.M;
       System.out.println("\n"+tag+":");
       System.out.println(runtime.freeMemory()/M+"M(free)/" + runtime.totalMemory()/M+"M(total)");
   }

   public static void main(String[] args) throws InterruptedException {

       PhantomReferenceTest.printlnMemory("1.原可用内存和总内存");
       byte[] object = new byte[10*PhantomReferenceTest.M];		
       PhantomReferenceTest.printlnMemory("2.实例化10M的数组后");

       //建立虚引用
       ReferenceQueue<Object> referenceQueue = new ReferenceQueue<Object>();
       PhantomReference<Object> phantomReference = new PhantomReference<Object>(object,referenceQueue);  

       PhantomReferenceTest.printlnMemory("3.建立虚引用后");
       System.out.println("phantomReference : "+phantomReference); 
       System.out.println("phantomReference.get() : "+phantomReference.get());
       System.out.println("referenceQueue.poll() : "+referenceQueue.poll());

       //断开byte[10*PhantomReferenceTest.M]的强引用
       object = null;  
       PhantomReferenceTest.printlnMemory("4.执行object = null;强引用断开后");

       System.gc();
       PhantomReferenceTest.printlnMemory("5.GC后");
       System.out.println("phantomReference : "+phantomReference); 
       System.out.println("phantomReference.get() : "+phantomReference.get());
       System.out.println("referenceQueue.poll() : "+referenceQueue.poll());	    

       //断开虚引用
       phantomReference = null;
       System.gc(); 
       PhantomReferenceTest.printlnMemory("6.断开虚引用后GC");
       System.out.println("phantomReference : "+phantomReference);
       System.out.println("referenceQueue.poll() : "+referenceQueue.poll());	    	
   }
}

在这里插入图片描述

5. JVM 的优化

在编译过程中，Java 编译器能选择给实例赋 null 值，从而标记实例为可回收

class Animal {
   public static void main(String[] args) {
       Animal lion = new Animal();
       System.out.println("Main is completed.");
   }

   protected void finalize() {
       System.out.println("Rest in Peace!");
   }
}

在上面的类中，lion 对象在实例化行后从未被使用过。因此 Java 编译器作为一种优化措施可以直接在实例化行后赋值 lion = null。因此，即使在 SOP 输出之前， finalize 函数也能够打印出 'Rest in Peace!'。
当然，我们不能证明这确定会发生，因为它依赖 JVM 的实现方式和运行时使用的内存而定。然而，我们能学习到一点：如果编译器看到该实例在未来再也不会被引用，那么编译器可以选择提早释放实例空间

南京.

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JVM 基础 (2) -- Java 中的四种引用

文章目录1. 强引用2. 软引用1. 强引用强引用就是指在程序代码之中普遍存在的，类似 Object obj = new Object() 这类的引用，只要强引用还存在，垃圾收集器永远不会回收掉被引用的对象，可以通过手动设置 obj = null；来断开强引用public class StrongReferenceTest { public static int M = 1024*...
复制链接

扫一扫

专栏目录