java中是怎样进行垃圾回收的?

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java中是怎样进行垃圾回收的?相关的知识,希望对你有一定的参考价值。

前面是我自己理解的后面是复制的
java中垃圾回收以前听老师讲好像是内存满了他才去做一次整体垃圾回收,在回收垃圾的同时会调用finalize方法.你在构造一个类时可以构造一个类时覆盖他的finalize方法以便于该类在被垃圾回收时执行一些代码,比如释放资源.

1.JVM的gc概述

gc即垃圾收集机制是指jvm用于释放那些不再使用的对象所占用的内存。java语言并不要求jvm有gc,也没有规定gc如何工作。不过常用的jvm都有gc,而且大多数gc都使用类似的算法管理内存和执行收集操作。

在充分理解了垃圾收集算法和执行过程后,才能有效的优化它的性能。有些垃圾收集专用于特殊的应用程序。比如,实时应用程序主要是为了避免垃圾收集中断,而大多数OLTP应用程序则注重整体效率。理解了应用程序的工作负荷和jvm支持的垃圾收集算法,便可以进行优化配置垃圾收集器。

垃圾收集的目的在于清除不再使用的对象。gc通过确定对象是否被活动对象引用来确定是否收集该对象。gc首先要判断该对象是否是时候可以收集。两种常用的方法是引用计数和对象引用遍历。

1.1.引用计数

引用计数存储对特定对象的所有引用数,也就是说,当应用程序创建引用以及引用超出范围时,jvm必须适当增减引用数。当某对象的引用数为0时,便可以进行垃圾收集。

1.2.对象引用遍历

早期的jvm使用引用计数,现在大多数jvm采用对象引用遍历。对象引用遍历从一组对象开始,沿着整个对象图上的每条链接,递归确定可到达(reachable)的对象。如果某对象不能从这些根对象的一个(至少一个)到达,则将它作为垃圾收集。在对象遍历阶段,gc必须记住哪些对象可以到达,以便删除不可到达的对象,这称为标记(marking)对象。

下一步,gc要删除不可到达的对象。删除时,有些gc只是简单的扫描堆栈,删除未标记的未标记的对象,并释放它们的内存以生成新的对象,这叫做清除(sweeping)。这种方法的问题在于内存会分成好多小段,而它们不足以用于新的对象,但是组合起来却很大。因此,许多gc可以重新组织内存中的对象,并进行压缩(compact),形成可利用的空间。

为此,gc需要停止其他的活动活动。这种方法意味着所有与应用程序相关的工作停止,只有gc运行。结果,在响应期间增减了许多混杂请求。另外,更复杂的 gc不断增加或同时运行以减少或者清除应用程序的中断。有的gc使用单线程完成这项工作,有的则采用多线程以增加效率。

2.几种垃圾回收机制

2.1.标记-清除收集器

这种收集器首先遍历对象图并标记可到达的对象,然后扫描堆栈以寻找未标记对象并释放它们的内存。这种收集器一般使用单线程工作并停止其他操作。

2.2.标记-压缩收集器

有时也叫标记-清除-压缩收集器,与标记-清除收集器有相同的标记阶段。在第二阶段,则把标记对象复制到堆栈的新域中以便压缩堆栈。这种收集器也停止其他操作。

2.3.复制收集器

这种收集器将堆栈分为两个域,常称为半空间。每次仅使用一半的空间,jvm生成的新对象则放在另一半空间中。gc运行时,它把可到达对象复制到另一半空间,从而压缩了堆栈。这种方法适用于短生存期的对象,持续复制长生存期的对象则导致效率降低。

2.4.增量收集器

增量收集器把堆栈分为多个域,每次仅从一个域收集垃圾。这会造成较小的应用程序中断。

2.5.分代收集器

这种收集器把堆栈分为两个或多个域,用以存放不同寿命的对象。jvm生成的新对象一般放在其中的某个域中。过一段时间,继续存在的对象将获得使用期并转入更长寿命的域中。分代收集器对不同的域使用不同的算法以优化性能。

2.6.并发收集器

并发收集器与应用程序同时运行。这些收集器在某点上(比如压缩时)一般都不得不停止其他操作以完成特定的任务,但是因为其他应用程序可进行其他的后台操作,所以中断其他处理的实际时间大大降低。

2.7.并行收集器

并行收集器使用某种传统的算法并使用多线程并行的执行它们的工作。在多cpu机器上使用多线程技术可以显著的提高java应用程序的可扩展性。

3.Sun HotSpot

1.4.1 JVM堆大小的调整

Sun HotSpot 1.4.1使用分代收集器,它把堆分为三个主要的域:新域、旧域以及永久域。Jvm生成的所有新对象放在新域中。一旦对象经历了一定数量的垃圾收集循环后,便获得使用期并进入旧域。在永久域中jvm则存储class和method对象。就配置而言,永久域是一个独立域并且不认为是堆的一部分。

下面介绍如何控制这些域的大小。可使用-Xms和-Xmx 控制整个堆的原始大小或最大值。

下面的命令是把初始大小设置为128M:

java –Xms128m

–Xmx256m为控制新域的大小,可使用-XX:NewRatio设置新域在堆中所占的比例。

下面的命令把整个堆设置成128m,新域比率设置成3,即新域与旧域比例为1:3,新域为堆的1/4或32M:

java –Xms128m –Xmx128m
–XX:NewRatio =3可使用-XX:NewSize和-XX:MaxNewsize设置新域的初始值和最大值。

下面的命令把新域的初始值和最大值设置成64m:

java –Xms256m –Xmx256m –Xmn64m

永久域默认大小为4m。运行程序时,jvm会调整永久域的大小以满足需要。每次调整时,jvm会对堆进行一次完全的垃圾收集。

使用-XX:MaxPerSize标志来增加永久域搭大小。在WebLogic Server应用程序加载较多类时,经常需要增加永久域的最大值。当jvm加载类时,永久域中的对象急剧增加,从而使jvm不断调整永久域大小。为了避免调整,可使用-XX:PerSize标志设置初始值。

下面把永久域初始值设置成32m,最大值设置成64m。

java -Xms512m -Xmx512m -Xmn128m -XX:PermSize=32m -XX:MaxPermSize=64m

默认状态下,HotSpot在新域中使用复制收集器。该域一般分为三个部分。第一部分为Eden,用于生成新的对象。另两部分称为救助空间,当Eden 充满时,收集器停止应用程序,把所有可到达对象复制到当前的from救助空间,一旦当前的from救助空间充满,收集器则把可到达对象复制到当前的to救助空间。From和to救助空间互换角色。维持活动的对象将在救助空间不断复制,直到它们获得使用期并转入旧域。使用-XX:SurvivorRatio 可控制新域子空间的大小。

同NewRation一样,SurvivorRation规定某救助域与Eden空间的比值。比如,以下命令把新域设置成64m,Eden占32m,每个救助域各占16m:

java -Xms256m -Xmx256m -Xmn64m -XX:SurvivorRation =2

如前所述,默认状态下HotSpot对新域使用复制收集器,对旧域使用标记-清除-压缩收集器。在新域中使用复制收集器有很多意义,因为应用程序生成的大部分对象是短寿命的。理想状态下,所有过渡对象在移出Eden空间时将被收集。如果能够这样的话,并且移出Eden空间的对象是长寿命的,那么理论上可以立即把它们移进旧域,避免在救助空间反复复制。但是,应用程序不能适合这种理想状态,因为它们有一小部分中长寿命的对象。最好是保持这些中长寿命的对象并放在新域中,因为复制小部分的对象总比压缩旧域廉价。为控制新域中对象的复制,可用-XX:TargetSurvivorRatio控制救助空间的比例(该值是设置救助空间的使用比例。如救助空间位1M,该值50表示可用500K)。该值是一个百分比,默认值是50。当较大的堆栈使用较低的 sruvivorratio时,应增加该值到80至90,以更好利用救助空间。用-XX:maxtenuring threshold可控制上限。

为放置所有的复制全部发生以及希望对象从eden扩展到旧域,可以把MaxTenuring Threshold设置成0。设置完成后,实际上就不再使用救助空间了,因此应把SurvivorRatio设成最大值以最大化Eden空间,设置如下:

java … -XX:MaxTenuringThreshold=0 –XX:SurvivorRatio=50000 …

4.BEA JRockit JVM的使用

Bea WebLogic 8.1使用的新的JVM用于Intel平台。在Bea安装完毕的目录下可以看到有一个类似于jrockit81sp1_141_03的文件夹。这就是 Bea新JVM所在目录。不同于HotSpot把Java字节码编译成本地码,它预先编译成类。JRockit还提供了更细致的功能用以观察JVM的运行状态,主要是独立的GUI控制台(只能适用于使用Jrockit才能使用jrockit81sp1_141_03自带的console监控一些cpu及 memory参数)或者WebLogic Server控制台。

Bea JRockit JVM支持4种垃圾收集器:

4.1.1.分代复制收集器

它与默认的分代收集器工作策略类似。对象在新域中分配,即JRockit文档中的nursery。这种收集器最适合单cpu机上小型堆操作。

4.1.2.单空间并发收集器

该收集器使用完整堆,并与背景线程共同工作。尽管这种收集器可以消除中断,但是收集器需花费较长的时间寻找死对象,而且处理应用程序时收集器经常运行。如果处理器不能应付应用程序产生的垃圾,它会中断应用程序并关闭收集。

分代并发收集器这种收集器在护理域使用排它复制收集器,在旧域中则使用并发收集器。由于它比单空间共同发生收集器中断频繁,因此它需要较少的内存,应用程序的运行效率也较高,注意,过小的护理域可以导致大量的临时对象被扩展到旧域中。这会造成收集器超负荷运作,甚至采用排它性工作方式完成收集。

4.1.3.并行收集器

该收集器也停止其他进程的工作,但使用多线程以加速收集进程。尽管它比其他的收集器易于引起长时间的中断,但一般能更好的利用内存,程序效率也较高。

默认状态下,JRockit使用分代并发收集器。要改变收集器,可使用-Xgc:,对应四个收集器分别为 gencopy,singlecon,gencon以及parallel。可使用-Xms和-Xmx设置堆的初始大小和最大值。要设置护理域,则使用- Xns:java –jrockit –Xms512m –Xmx512m –Xgc:gencon –Xns128m…尽管JRockit支持-verbose:gc开关,但它输出的信息会因收集器的不同而异。JRockit还支持memory、 load和codegen的输出。

注意 :如果 使用JRockit JVM的话还可以使用WLS自带的console(C:\bea\jrockit81sp1_141_03\bin下)来监控一些数据,如cpu, memery等。要想能构监控必须在启动服务时startWeblogic.cmd中加入-Xmanagement参数。

5.如何从JVM中获取信息来进行调整

-verbose.gc开关可显示gc的操作内容。打开它,可以显示最忙和最空闲收集行为发生的时间、收集前后的内存大小、收集需要的时间等。打开- xx:+ printgcdetails开关,可以详细了解gc中的变化。打开-XX: + PrintGCTimeStamps开关,可以了解这些垃圾收集发生的时间,自jvm启动以后以秒计量。最后,通过-xx: + PrintHeapAtGC开关了解堆的更详细的信息。为了了解新域的情况,可以通过-XX:=PrintTenuringDistribution开关了解获得使用期的对象权。

6.Pdm系统JVM调整

6.1.服务器:前提内存1G 单CPU

可通过如下参数进行调整:-server 启用服务器模式(如果CPU多,服务器机建议使用此项)

-Xms,-Xmx一般设为同样大小。 800m

-Xmn 是将NewSize与MaxNewSize设为一致。320m

-XX:PerSize 64m

-XX:NewSize 320m 此值设大可调大新对象区,减少Full GC次数

-XX:MaxNewSize 320m

-XX:NewRato NewSize设了可不设。

-XX: SurvivorRatio

-XX:userParNewGC 可用来设置并行收集

-XX:ParallelGCThreads 可用来增加并行度

-XXUseParallelGC 设置后可以使用并行清除收集器

-XX:UseAdaptiveSizePolicy 与上面一个联合使用效果更好,利用它可以自动优化新域大小以及救助空间比值

6.2.客户机:通过在JNLP文件中设置参数来调整客户端JVM

JNLP中参数:initial-heap-size和max-heap-size

这可以在framework的RequestManager中生成JNLP文件时加入上述参数,但是这些值是要求根据客户机的硬件状态变化的(如客户机的内存大小等)。建议这两个参数值设为客户机可用内存的60%(有待测试)。为了在动态生成JNLP时以上两个参数值能够随客户机不同而不同,可靠虑获得客户机系统信息并将这些嵌到首页index.jsp中作为连接请求的参数。

在设置了上述参数后可以通过Visualgc 来观察垃圾回收的一些参数状态,再做相应的调整来改善性能。一般的标准是减少fullgc的次数,最好硬件支持使用并行垃圾回收(要求多CPU)。
参考技术A

您好,提问者:    

   1、Java有专门一个线程负责垃圾回收机制。

   2、当一个对象为null时垃圾回收线程会不定期的进行回收。

   3、我们可以在程序中使用System.gc来通知JVM进行回收,如下代码:

public class Gc_ThreadDemo extends Thread
//重写父类的垃圾回收方法
public void run()
for(int i = 0; i < 10; i++)
System.out.println(Thread.currentThread().getName());



//默认extends Object
@Override 
public void finalize()
System.out.println(Thread.currentThread().getName()+"....垃圾回收方法运行");


//主方法
public static void main(String[] args)
Gc_ThreadDemo gc = new Gc_ThreadDemo();
for(int i = 0; i < 10; i++)
new Gc_ThreadDemo();//制造匿名对象,好让JVM执行垃圾回收方法。
System.gc();//通知JVM执行垃圾回收

gc.start();
System.out.println(Thread.currentThread().getName());



//我们正常编译:javac -d classes Gc_ThreadDemo.java
//如果要看到JVM线程回收情况,我们可以使用:java -verbose:gc -cp classes Gc_ThreadDemo

参考技术B Java有自动垃圾回收机制,只是回收再何时就不一定了。你可以强制回收啊,System.gc() 参考技术C 当内存中含有一些空引用, 弱引用对象的时候, jvm会去自动的进行垃圾回收, 不需要像C一样手动调用

虽然java也提供了System.gc();手动调用垃圾回收, 不过吧... 这个请求jvm不一定买账, 也就是说, 无论你有没有手动的调用gc方法, 它都是不受你控制的. 决定权在于JVM自己的机制
参考技术D java 有自己的垃圾回收装置 是在规定时间中自己去处理垃圾

Java虚拟机笔记:GC垃圾回收

为什么要了解GC

我们都知道Java开发者在开发过程中是不需要关心对象的回收的,因为Java虚拟机的原因,它会自动回收那些失效的垃圾对象。那我们为什么还要去了解GC和内存分配呢?

答案很简单:当我们需要排查各种内存溢出、内存泄漏时,当垃圾收集器成为系统达到更高并发量的瓶颈时,我们就需要对这些"自动化"的技术实施必要的监控和调节。

 

回收哪些对象

我们知道在Java内存运行时数据区域中,虚拟机栈、本地方法栈和程序计数器是线程隔离的数据区,随线程而生,随线程而灭;栈中的栈帧随着方法的进入和退出而有条不紊地执行着出栈和入栈操作。每一个栈帧中分配多少内存基本是在类结构确定下来时就已知的。因此这几个区域的内存分配和回收都具备确定性,在这几个区域内就不需要过多考虑回收的问题,因为方法结束或者线程结束时,内存自然就跟随着回收了。

而方法区和堆是由所有线程共享的数据区,一个接口中的多个实现类需要的内存可能不一样,一个方法中的多个分支需要的内存也可能不一样,我们只有在程序处于运行时才知道会创建哪些对象,这部分内存的分配和回收都是动态的,垃圾收集器所关注的就是这部分内存。

 

如何判断对象可回收

1.引用计数法

原理:给对象中添加一个引用计数器,每当有一个地方引用它时,计数器值就加1;当引用失效时,计数器值就减1;任何时刻计数器为0的对象就是不可能再被使用的。

优点:实现简单,判断效率高。

缺点:很难解决对象之间相互循环引用的问题。(主流Java虚拟机里面没有选用该种方法)。

举个简单的例子,请看代码清单中的testGC()方法:对象objA和objB都有字段instance,赋值令objA.instance = objB及objB.instance = objA,除此之外,这两个对象再无任何引用,实际上这两个对象已经不可能再被访问,但是它们因为互相引用着对方,导致它们的引用计数都不为0,于是引用计数算法无法通知GC收集器回收它们。

 1 /**  
 2  * testGC()方法执行后,objA和objB会不会被GC呢?  
 3  * @author zzm  
 4  */  
 5 public class ReferenceCountingGC {  
 6  
 7   public Object instance = null;  
 8  
 9   private static final int _1MB = 1024 * 1024;  
10  
11   /**  
12    * 这个成员属性的唯一意义就是占点内存,以便能在GC日志中看清楚是否被回收过  
13    */  
14   private byte[] bigSize = new byte[2 * _1MB];  
15  
16   public static void testGC() {  
17    ReferenceCountingGC objA = new ReferenceCountingGC();  
18    ReferenceCountingGC objB = new ReferenceCountingGC();  
19    objA.instance = objB;  
20    objB.instance = objA;  
21  
22    objA = null;  
23    objB = null;  
24  
25    //假设在这行发生GC,objA和objB是否能被回收?  
26    System.gc();  
27   }  
28 } 

运行结果

 1 [Full GC (System) [Tenured: 0K->210K(10240K), 0.0149142 secs] 4603K->210K(19456K), [Perm : 2999K->2999K(21248K)], 0.0150007 secs] [Times: user=0.01 sys=0.00, real=0.02 secs]  
 2 Heap  
 3  def new generation   total 9216K, used 82K [0x00000000055e0000, 0x0000000005fe0000, 0x0000000005fe0000)  
 4   Eden space 8192K,   1% used [0x00000000055e0000, 0x00000000055f4850, 0x0000000005de0000)  
 5   from space 1024K,   0% used [0x0000000005de0000, 0x0000000005de0000, 0x0000000005ee0000)  
 6   to   space 1024K,   0% used [0x0000000005ee0000, 0x0000000005ee0000, 0x0000000005fe0000)  
 7  tenured generation   total 10240K, used 210K [0x0000000005fe0000, 0x00000000069e0000, 0x00000000069e0000)  
 8    the space 10240K,   2% used [0x0000000005fe0000, 0x0000000006014a18, 0x0000000006014c00, 0x00000000069e0000)  
 9  compacting perm gen  total 21248K, used 3016K [0x00000000069e0000, 0x0000000007ea0000, 0x000000000bde0000)  
10    the space 21248K,  14% used [0x00000000069e0000, 0x0000000006cd2398, 0x0000000006cd2400, 0x0000000007ea0000)  
11 No shared spaces configured. 

从运行结果中可以清楚看到,GC日志中包含“4603K->210K”,意味着虚拟机并没有因为这两个对象互相引用就不回收它们,这也从侧面说明虚拟机并不是通过引用计数算法来判断对象是否存活的。

 

2.可达性算法(根搜索算法)

原理:通过一系列的称为"GC Roots"的对象作为起始点,从这些节点开始向下搜索,搜索所走过的路径称为引用链,当一个对象到GC Roots没有任何引用链相连(用图论的话说,就是从GC Roots到这个对象不可达)时,则证明此对象是不可用的。

 

图中,对象object 5、object 6、object 7虽然互相有关联,但是它们到GC Roots是不可达的,所以它们将会被判定为是可回收的对象。

在Java语言中,可作为GC Roots的对象包括下面几种:

  • 虚拟机栈(栈帧中的本地变量表)中引用的对象。
  • 方法区中类静态属性引用的对象。
  • 方法区中常量引用的对象。
  • 本地方法栈中JNI(即一般说的Native方法)引用的对象。

 

对象的引用 

无论是通过引用计数算法判断对象的引用数量,还是通过根搜索算法判断对象的引用链是否可达,判定对象是否存活都与“引用”有关。

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

1.强引用(StrongReference)

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

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

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

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

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

 

2.软引用(SoftReference)

用来描述一些还有用,但并非必需的对象。

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

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

当内存不足时,等价于:

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

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

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

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

这时候就可以使用软引用。

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

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

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

 

3.弱引用(WeakReference)

也是用来描述非必需对象的,但是它的强度比软引用更弱一些,被弱引用关联的对象只能生存到下一次垃圾收集发生之前。当垃圾收集器工作时,无论当前内存是否足够,都会回收掉只被弱引用关联的对象。在JDK 1.2之后,提供了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)

“虚引用”顾名思义,就是形同虚设,也称为幽灵引用或者幻影引用,它是最弱的一种引用关系。一个对象是否有虚引用的存在,完全不会对其生存时间构成影响,也无法通过虚引用来取得一个对象实例。为一个对象设置虚引用关联的唯一目的就是希望能在这个对象被收集器回收时收到一个系统通知。

在JDK 1.2之后,提供了PhantomReference类来实现虚引用。

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

虚引用主要用来跟踪对象被垃圾回收器回收的活动。

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

我们可以声明虚引用来引用我们感兴趣的对象,在GC要回收的时候,GC收集器会把这个对象添加到ReferenceQueue,这样我们如果检测到ReferenceQueue中有我们感兴趣的对象的时候,说明GC将要回收这个对象了。此时我们可以在GC回收之前做一些其他事情,比如记录些日志什么的。

 

4种引用的总结

Java4种引用的级别由高到低依次为:

强引用  >  软引用  >  弱引用  >  虚引用

通过表格来看一下他们之间在垃圾回收时的区别:

 

对象死亡的两次标记过程 

即使在可达性分析算法中不可达的对象,也并非是“非死不可”的,这时候它们暂时处于“缓刑”阶段,要真正宣告一个对象死亡,至少要经历再次标记过程。

标记的前提是对象在进行可达性分析后发现没有与GC Roots相连接的引用链。

1).第一次标记并进行一次筛选。

筛选的条件是此对象是否有必要执行finalize()方法。

当对象没有覆盖finalize方法,或者finzlize方法已经被虚拟机调用过,虚拟机将这两种情况都视为“没有必要执行”,对象被回收。

2).第二次标记

如果这个对象被判定为有必要执行finalize()方法,那么这个对象将会被放置在一个名为:F-Queue的队列之中,并在稍后由一条虚拟机自动建立的、低优先级的Finalizer线程去执行。这里所谓的“执行”是指虚拟机会触发这个方法,但并不承诺会等待它运行结束。这样做的原因是,如果一个对象finalize()方法中执行缓慢,或者发生死循环(更极端的情况),将很可能会导致F-Queue队列中的其他对象永久处于等待状态,甚至导致整个内存回收系统崩溃。

finalize()方法是对象脱逃死亡命运的最后一次机会,稍后GC将对F-Queue中的对象进行第二次小规模标记,如果对象要在finalize()中成功拯救自己----只要重新与引用链上的任何的一个对象建立关联即可,譬如把自己赋值给某个类变量或对象的成员变量,那在第二次标记时它将移除出“即将回收”的集合。如果对象这时候还没逃脱,那基本上它就真的被回收了。
流程图如下: 

一次对象自我拯救的演示

 1 /**
 2  * 此代码演示了两点
 3  * 1、对象可以在被GC时自我拯救
 4  * 2、这种自救的机会只有一次,因为一个对象的finalize()方法最多只能被系统自动调用一次。
 5  */
 6 public class FinalizeEscapeGC {
 7     public static FinalizeEscapeGC SAVE_HOOK = null;
 8 
 9     public void isAlive() {
10         System.out.println("yes, I am still alive");
11     }
12 
13     protected void finalize() throws Throwable {
14         super.finalize();
15         System.out.println("finalize method executed!");
16         FinalizeEscapeGC.SAVE_HOOK = this;
17     }
18 
19     public static void main(String[] args) throws InterruptedException {
20         SAVE_HOOK = new FinalizeEscapeGC();
21 
22         //对象第一次成功拯救自己
23         SAVE_HOOK = null;
24         System.gc();
25 
26         //因为finalize方法优先级很低,所有暂停0.5秒以等待它
27         Thread.sleep(500);
28         if (SAVE_HOOK != null) {
29             SAVE_HOOK.isAlive();
30         } else {
31             System.out.println("no ,I am dead QAQ!");
32         }
33 
34         //-----------------------
35         //以上代码与上面的完全相同,但这次自救却失败了!!!
36         SAVE_HOOK = null;
37         System.gc();
38 
39         //因为finalize方法优先级很低,所有暂停0.5秒以等待它
40         Thread.sleep(500);
41         if (SAVE_HOOK != null) {
42             SAVE_HOOK.isAlive();
43         } else {
44             System.out.println("no ,I am dead QAQ!");
45         }
46     }
47 }

运行结果

1 finalize method executed!
2 yew, I am still alive 
3 no ,I am dead QAQ!

从结果可以看出,SAVE_HOOK对象的finalize()方法确实被GC收集器触发过,并且在被收集前成功逃脱了。

注意:任何一个对象的finalize()方法都只会被系统自动调用一次,如果对象面临下一次回收,它的finalize()方法不会被再次执行,因此第二段代码的自救行动失败了,并且建议大家尽量避免使用它 。

同类随笔

Java虚拟机笔记(一):类加载机制

Java虚拟机笔记(二):GC垃圾回收

Java虚拟机笔记(三):垃圾收集算法

Java虚拟机笔记(四):垃圾收集器

Java虚拟机笔记(五):JVM中对象的分代

 

参考资料:

1.《深入理解Java虚拟机:JVM高级特性与最佳实践》 

2. https://my.oschina.net/ydsakyclguozi/blog/404389

3. http://blog.csdn.net/ochangwen/article/details/51406779

 

以上是关于java中是怎样进行垃圾回收的?的主要内容,如果未能解决你的问题,请参考以下文章

JVM垃圾回收

JVM垃圾回收机制是怎样的,何时触发YoungGC或FullGC操作

JAVA垃圾回收-可达性分析算法

JVM垃圾回收机制

垃圾回收机制算法分析

Java学习笔记3.11.2 垃圾回收 - 垃圾回收的实现方式