JVM浅出深入系列-第三章对象的生命周期与垃圾回收

对象的生命周期

1、对象已死吗？

概念：
- 存活：正在被使用的对象。
- 已死：不可能再被任何途径使用的对象。

1）引用计数算法

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

缺陷：无法解决循环引用，会导致内存溢出！（Java已经不用了此算法了，python还在用，原因在于其性能好）
优点：算法性能相对于可达性分析算法更高。

2）可达性分析算法

在Java中，是通过可达性分析(Reachability Analysis)来判定对象是否存活的。这个算法的基本思想就是通过一系列的称为“GC Roots”的对象作为起始点，从这些节点开始想下搜索，搜索所走过的路径称为引用链(Reference Chain),当一个对象到GC Roots没有任何引用链相连(即:GC Roots到这个对象不可达)时，则证明此对象是不可用的。

在这里插入图片描述

在Java语言中，可作为GC Roots的对象(即:GC Root Set)包括下面几种：
- 虚拟机栈(栈帧中的本地变量表)中引用的对象。
- 方法区中类静态属性引用的对象。
- 方法区汇总常量引用的对象。
- 本地方法栈中JNI(即一般说的Native方法)引用的对象。

3）再谈引用（强软弱虚）

在JDK1.2以前，Java中的引用的定义很传统:如果reference类型的数据中存储的数值代表的是另外一块内存的起始地址，就称这块内存代表着一个引用。

在JDK1.2(含)之后，Java对引用的概念进行了补充，将引用分为强引用(String Reference)、软引用(Soft Reference)、弱引用(Weak Reference)、虚引用(Phantom Reference)4中，这4种引用的引用强度依次逐渐减弱。

强引用：
- 在 Java 中最常见的就是强引用，也是我们在开发过程中经常会使用到的引用.把一个对象赋给一个引用变量，这个引用变量就是一个强引用。当一个对象被强引用变量引用时，它处于可达状态，它是不可能被垃圾回收机制回收的，即使该对象以后永远都不会被用到 JVM 也不会回收。因此强引用是造成 Java内存泄漏的主要原因之一。

软引用：

软引用需要用 SoftReference 类来实现，对于只有软引用的对象来说，当系统内存足够时它不会被回收，当系统内存空间不足时它会被回收。软引用通常用在对内存敏感的程序中。

 public class SoftReferenceDemo {
    public static void main(String[] args) {
        //。。。一堆业务代码
        Worker a = new Worker();
        // 。。业务代码使用到了我们的Worker实例
        // 使用完了a，将它设置为soft 引用类型，并且释放强引用； 
        SoftReference sr = new SoftReference(a);
        a = null;
        // 下次使用时 
        if (sr != null) {
            a = (Worker) sr.get();
        } else {
            // GC由于内存资源不足，可能系统已回收了a的软引用， 
            // 因此需要重新装载。 
            a = new Worker();
            sr = new SoftReference(a);
        }
    }
}

在系统中将要发生内存溢出异常之前，将会把这些对象列进回收范围之中进行第二次回收。如果这次回收还没有足够的内存，才会抛出内存溢出异常。
除了强引用外，其它三种引用方式中，软引用使用得最多。在开发中，可以利用软引用实现高速缓存。

弱引用：

弱引用需要用 WeakReference 类来实现，它比软引用的生存期更短，对于只有弱引用的对象来说，只要垃圾回收机制一运行，不管 JVM 的内存空间是否足够，总会回收该对象占用的内存。弱引用需要用 WeakReference 类来实现，它比软引用的生存期更短，对于只有弱引用的对象来说，只要垃圾回收机制一运行，不管 JVM 的内存空间是否足够，总会回收该对象占用的内存。


public class WeakReferenceDemo {
    public static void main(String[] args) throws InterruptedException {
        //100M的缓存数据
        byte[] cacheData = new byte[100 * 1024 * 1024];
        // 将缓存数据用软引用持有
        WeakReference<byte[]> cacheRef = new WeakReference<>(cacheData);
        System.out.println("第一次GC前" + cacheData);
        System.out.println("第一次GC前" + cacheRef.get());
        // 进行一次GC后查看对象的回收情况
        System.gc();
        // 等待GC
        Thread.sleep(500);
        System.out.println("第一次GC后" + cacheData);
        System.out.println("第一次GC后" + cacheRef.get());
        // 将缓存数据的强引用去除
        cacheData = null;
        System.gc();
        // 等待GC
        Thread.sleep(500);
        System.out.println("第二次GC后" + cacheData);
        System.out.println("第二次GC后" + cacheRef.get());
    }
}

// 第一次GC前[B@3d075dc0
// 第一次GC前[B@3d075dc0
// 第一次GC后[B@3d075dc0
// 第一次GC后[B@3d075dc0
// 第二次GC后null
// 第二次GC后null

虚引用（幽灵引用、幻影引用）：
- 最弱的一种引用。一个对象是否有虚引用的存在，完全不会对其生存时间造成影响，也无法通过虚引用来取得一个对象实例。为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知

4）生存还是死亡？

对象的生命周期：
- 创建阶段：
  其实我们在探讨类加载的时候就已经探讨了一部分对象创建的情况
- 为对象分配存储空间
- 开始构造对象
- 从超类到子类对static成员进行初始化
- 超类成员变量按顺序初始化，
- 递归调用超类的构造方法
- 子类成员变量按顺序初始化，子类构造方法调用
- 一旦对象被创建，并被分派给某些变量赋值，这个对象的状态就切换到了应用阶段
- 应用阶段：
  - 对象至少被一个强引用持有着。
- 不可见阶段：
  - 当一个对象处于不可见阶段时，说明程序本身不再持有该对象的任何强引用，虽然该这些引用仍然是存在着的。
  - 简单说就是程序的执行已经超出了该对象的作用域了。
- 不可达阶段：
  - 对象处于不可达阶段是指该对象不再被任何强引用所持有。
  - 与“不可见阶段”相比，“不可见阶段”是指程序不再持有该对象的任何强引用，这种情况下，该对象仍可能被 JVM 等系统下的某些已装载的静态变量或线程或 JNI 等强引用持有着，这些特殊的强引用被称为” GC root ”。存在着这些 GC root 会导致对象的内存泄露情况，无法被回收。
- 收集阶段：
  当垃圾回收器发现该对象已经处于“不可达阶段”并且垃圾回收器已经对该对象的内存空间重新分配做好准备时，则对象进入了“收集阶段”。如果该对象已经重写了 finalize() 方法，则会去执行该方法的终端操作。
  - finalize(): 对象的一次复活币
    - 会影响JVM的对象分配与回收速度
      
      在分配该对象时，JVM需要在垃圾回收器上注册该对象，以便在回收时能够执行该重载方法；在该方法的执行时需要消耗CPU时间且在执行完该方法后才会重新执行回收操作，即至少需要垃圾回收器对该对象执行两次GC。
    - 可能造成该对象的再次“复活”
      
      在finalize()方法中，如果有其它的强引用再次持有该对象，则会导致对象的状态由“收集阶段”又重新变为“应用阶段”。这个已经破坏了Java对象的生命周期进程，且“复活”的对象不利用后续的代码管理。
- 终结阶段：
  - 当对象执行完finalize()方法后仍然处于不可达状态时，则该对象进入终结阶段。在该阶段是等待垃圾回收器对该对象空间进行回收
- 对象空间重新分配阶段：
  - 垃圾回收器对该对象的所占用的内存空间进行回收或者再分配了，则该对象彻底消失了，称之为“对象空间重新分配阶段”。

在这里插入图片描述

垃圾收集算法

已经能够确定一个对象为垃圾之后，接下来要考虑的就是回收，怎么回收呢？得要有对应的算法，下面介绍常见的垃圾回收算法。

1、标记-清除(Mark-Sweep)

标记
找出内存中需要回收的对象，并且把它们标记出来
清除
清除掉被标记需要回收的对象，释放出对应的内存空间
缺点：
- 空间碎片：
  会产生大量不连续的内存碎片，空间碎片太多可能会导致以后在程序运行过程中需要分配较大对象时，无法找到足够的连续内存而不得不提前触发另一次垃圾收集动作。
- 标记和清除两个过程都比较耗时，效率不高