Wilder's Blog.

JVM学习笔记:GC(2)

JVM学习笔记
字数统计: 1.4k阅读时长: 5 min
2018/05/29 Share

​ 今天我们来看看 JVM 如何判断对象是否可以被回收……

对象已死吗

在堆里存放着几乎所有的实例对象实例，垃圾收集器在对堆进行回收前，第一件事情就是要确定这些对象之中哪些还“存活”着，哪些已经“死去”。接下来介绍几种算法。

一、引用计数算法

引用计数算法的流程是这样子的：给对象添加一个引用计数器，每次当有一个地方引用它时，计数器值就加1；当引用失效时，计数器值就减1；任何时刻计数器为 0 的对象就是不可能再被使用的。但是 JVM 并没有使用这种算法来管理内存，最主要的原因就是它很难解决对象之间相互循环引用的问题。我们来看一段代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Wilder{
  public Object instance = null;
  
  public static void testGC(){
  	Wilder wilderA = new Wilder();
  	Wilder wilderB = new Wilder();
    wilderA.instance = wilderB;
    wilderB.instance = wilderA;
    
    wilderA = null;
    wilderB = null;
    
    System.gc();
  }
}

如果JVM使用的是引用计数算法：最后两个对象都指向了 null ， 但是由于两者相互引用，所以两者的引用计数器不为 0 ，所以即时 GC 了两个对象都不会被回收。

但是从结果的 GC 日志上来看，这两个对象被 JVM 回收了，所以说使用的并不是这种算法。

二、可达性分析算法

这个算法的基本思想就是通过一系列的称为“GC Roots”的对象作为起始点，从这些节点开始向下搜索，搜索所走过的路径称为引用链（Reference Chain），当一个对象到GC Roots没有任何引用链相连（也就是GC Roots到这个对象不可达），则证明此对象是不可用的。

可达性算法

从图中看出 Object_E、Object_F、Object_G 从GC Root 搜索到，所以 JVM 认为这些对象不可用了，将会把这些对象回收。

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

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

三、生存还是死亡

对象被宣告死亡要经历两个阶段：

  1. 第一个阶段就是可达性分析，判断对象是否具有有效引用
  2. 第二个阶段就是判断对象是否有必要执行 finalize（）方法。当对象没有覆盖finalize（）方法或者finalize（）方法已经被虚拟机调用过，虚拟机将这两种情况称为“没有必要执行”，就是对象已经没有任何机会完成救赎。如果认为这个对象有必要执行 finalize() 方法，那么这个对象将会放置在一个叫做 F-Queue 的队列之中，并在稍后由一个由虚拟机自动建立的、低优先级的 Finalizer 线程区执行它。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class FinalizeEscapeGc {
    private static FinalizeEscapeGc SAVE_HOOK = null;
    public void isAlive(){
        System.out.println("yes, i am still alive");
    }
    @Override
    protected  void finalize() throws Throwable{
        super.finalize();
        System.out.println("finalize method executed!");
        FinalizeEscapeGc.SAVE_HOOK = this;
    }
    public static void main(String[] args) throws InterruptedException {
        SAVE_HOOK = new FinalizeEscapeGc();
        SAVE_HOOK = null;
        System.gc();
        Thread.sleep(500);
        if(SAVE_HOOK!= null){
            SAVE_HOOK.isAlive();
        }else{
            System.out.println("no ,i am dead ");
        }
        SAVE_HOOK = null;
        System.gc();
        Thread.sleep(500);
        if(SAVE_HOOK!= null){
            SAVE_HOOK.isAlive();
        }else{
            System.out.println("no ,i am dead ");
        }
    }
}

程序运行的结果：

1
2
3
finalize method executed!
yes, i am still alive
no ,i am dead

从结果我们可以看到，SAVE_HOOK 对象确实在被 GC 回收之前调用过 finalize() 方法。但是由于任何一个对象的 finalize() 方法只会被系统自动调用一次，所以当进行第二次回收的时候该对象将会被垃圾回收器进行收集。

四、再谈引用

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

强引用

Object obj = new Object() 这一类的引用称之为强引用，强引用在程序代码之中是普遍存在的。只要强引用还存在，垃圾收集器永远不会回收掉被引用的对象。

软引用

软引用是用来描述一些还有用但并非必须的对象。对于软引用关联的对象，在系统将要发生内存溢出之前，将会把这些对象列进回收范围之中进行第二次回收。如果这次回收还没有足够的内存，才会抛出内存溢出异常。JDK 提供了 SoftReference 类来实现软引用。

弱引用

强度比软引用更弱一些，被弱引用关联的对象只能生存到下一次垃圾收集发生之前。当垃圾收集器发生工作时，无论内存是否足够，都会回收掉弱引用关联的对象。 JDK 提供了 WeakReference 来实现弱引用。

虚引用

最弱的一种引用关系。一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来取得一个对象实例。为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知。 JDK 提供了 PhantomReference 类来实现虚引用

原文作者：Wilder Gao

原文链接：http://wildergao.github.io/2018/05/29/JVM学习笔记-GC（2）/

发表日期：May 29th 2018, 1:12:03 am

更新日期：May 30th 2018, 2:18:40 pm

版权声明：本文采用知识共享署名-非商业性使用 4.0 国际许可协议进行许可

CATALOG
  1. 1. 对象已死吗
    1. 1.1. 一、引用计数算法
    2. 1.2. 二、可达性分析算法
    3. 1.3. 三、生存还是死亡
    4. 1.4. 四、再谈引用
      1. 1.4.1. 强引用
      2. 1.4.2. 软引用
      3. 1.4.3. 弱引用
      4. 1.4.4. 虚引用
Total : 24
2018
JVM学习笔记 Java小技巧 SpringBoot Spark Netty 我有话说 并发 刷题之路