《深入Java虚拟机学习笔记》- 第7章 类型的生命周期/对象在JVM中的生命周期

一、类型生命周期的开始

1. 如图所示
   
2. 初始化时机
   • 所有Java虚拟机实现必须在每个类或接口首次主动使用时初始化；
   • 以下几种情形符合主动使用的要求：
     • 当创建某个类的新实例时（或者通过在字节码中执行new指令，或者通过不明确的创建、反射、克隆和反序列化）；
     • 当调用某个类的静态方法时（即在字节码中执行invokestatic指令）；
     • 当使用某个类或接口的静态字段，或者对该字段赋值时（用final修饰的静态字段除外，它被初始化为一个编译时常量表达式）；
     • 当调用Java API中的某些反射方法；
     • 当初始化某个类的子类时（子类初始化时，要求父类已经被初始化）；
     • 当虚拟机启动时某个被标明为启动类的类（即含有main方法的那个类）；
   • 无论如何，如果一个类在首次主动使用前还没有被装载和连接的话，那它必须在此时被装载和连接，这样才能初始化；
3. 默认值和初始值
   • 在准备阶段，虚拟机把给类变量分配的内存设置为默认值；
   • 在初始化阶段，为类变量赋予正确的初始值；
   • 在Java代码中，一个正确的初始值是通过类变量初始化语句或静态初始化语句给出的；如：
     static int size = 3 * (int) (Math.random() * 5.0);
     或
     static int size;
     static {
         size = 3 * (int) (Math.random() * 5.0);
     }
4. <clinit>()方法
   • 所有的类变量初始化语句和类型的静态初始化器都被Java编译器收集在一起，放在一个特殊的方法中，该方法为"<clinit>()"方法；该方法只能由Java虚拟机调用；
   • 初始化一个类包含两步：
     • 如果类存在直接超类的话，且直接超类没有初始化，就先初始化直接超类；第一个被初始化的类永远是Object；
     • 如果类存在一个类初始化方法，就执行此方法；
   • 初始化接口不需要初始化它的父接口，只需一步：如果接口存在一个接口初始化方法，则执行此方法；
   • 以下的类没有<clinit>()方法
     • 如果类没有声明任何类变量，也没有静态初始化语句；
     • 如果类声明了类变量，但是没有明确使用类变量初始化语句或静态初始化语句来初始化它们；
     • 如果类仅包含静态final变量的初始化语句，而且这些类变量初始化语句采用编译时常量表达式；

二、对象的生命周期

1. 主动使用和被动使用
   • 前面提到过，JVM在首次主动使用类型时初始化它们；
   • 使用一个非常量的静态字段只有当类或者接口的确声明了这个字段才是主动使用；如类中声明的字段可能会被子类引用、接口中声明的字段可能会被子接口或是实现了该接口的类引用；对于子类、子接口和实现了接口的类来说，都是被动使用，它们不会触发初始化；
2. <init>()方法
   • Java编译器为它编译的每一个类都至少生成一个实例初始化方法，该方法称为"<init>"方法；
   • 针 对源代码中的每一个类的构造方法，Java编译器都产生一个<init>()方法，如果类没有明确地声明任何构造方法，编译器默认产生一个无 参数的构造方法，它仅仅调用超类的无参构造方法，同时也创建一个<init>()方法，对应默认构造方法；
   • 一个<init>()方法中可能包含三种代码：调用另一个<init>()方法、实现对任何实例变量的初始化、构造方法体的代码
     • 如果构造方法通过明确地调用同一个类中的另一个构造方法(this())，它对应的<init>()方法由由两部分组成
       1. 一个同类的<init>方法的调用
       2. 实现了对应构造方法的方法体的字节码
     • 如果构造方法不是通过一个this()调用开始，而且这个对象不是Object，<init>()方法则由三部分组成
       1. 一个超类的<init>()方法的调用；
       2. 任意实例变量初始化方法的字节码；
       3. 实现了对应构造方法的方法体的字节码
3. 对象的终结
   • 如果类声明了一个名为void finalize()方法，垃圾收集器会在释放这个实例的内存前执行这个方法一次；
   • 垃圾收集器最多只会调用一个对象的终结方法一次；如果终结方法代码执行后，对象重新被引用了(即复活)，随后再次变得不被引用，垃圾收集器不会第二次调用终结方法；

三、类型的卸载

1. 和对象一样，当类型不再需要时，可以通过卸载来释放内存空间；
2. 类型的卸载也是通过垃圾回收器完成的；

四、对象的生命周期

1. 垃圾回收

垃圾回收是Java程序设计中内存管理的核心概念，JVM的内存管理机制被称为垃圾回收机制。

一个对象创建后被放置在JVM的堆内存中，当永远不再引用这个对象时，它将被JVM在堆内存中回收。被创建的对象不能再生，同时也没有办法通过程序语句释放它们。即当对象在JVM运行空间中无法通过根集合到达(找到)时,这个对象被称为垃圾对象。根集合是由类中的静态引用域与本地引用域组成的。JVM通过根集合索引对象。

在做Java应用开发时经常会用到由JVM管理的两种类型的内存：堆内存和栈内存。简单来讲，堆内存主要用来存储程序在运行时创建或实例化的对象与变量。例如通过new关键字创建的对象。而栈内存则是用来存储程序代码中声明为静态或非静态的方法。

(1) 堆内存

堆内存在JVM启动的时候被创建，堆内存中所存储的对象可以被JVM自动回收，不能通过其他外部手段回收，也就是说开发人员无法通过添加相关代码的手段来回收堆内存中的对象。堆内存通常情况下被分为两个区域：新对象区域与老对象区域。

新对象区域：又可细分为三个小区域：伊甸园区域、From区域与To区域。伊甸园区域用来保存新创建的对象，它就像一个堆栈，新的对象被创建，就像指向该栈的指针在增长一样，当伊甸园区域中的对象满了之后，JVM系统将要做到可达性测试，主要任务是检测有哪些对象由根集合出发是不可达的，这些对象就可以被JVM回收，并且将所有的活动对象从伊甸园区域拷贝到To区域，此时一些对象将发生状态交换，有的对象就从To区域被转移到From区域，此时From区域就有了对象。上面对象迁移的整个过程，都是由JVM控制完成的。

老对象区域：在老对象区域中的对象仍然会有一个较长的生命周期，大多数的JVM系统垃圾对象，都是源于"短命"对象，经过一段时间后，被转入老对象区域的对象，就变成了垃圾对象。此时，它们都被打上相应的标记，JVM系统将会自动回收这些垃圾对象，建议不要频繁地强制系统作垃圾回收，这是因为JVM会利用有限的系统资源，优先完成垃圾回收工作，导致应用无法快速地响应来自用户端的请求，这样会影响系统的整体性能。

(2) 栈内存

堆内存主要用来存储程序在运行时创建或实例化的对象与变量。例如通过new关键字创建的对象。而栈内存则是用来存储程序代码中声明为静态或非静态的方法。

2. JVM中对象的生命周期

在JVM运行空间中，对象的整个生命周期大致可以分为7个阶段：
   创建阶段；
   应用阶段；
   不可视阶段；
   不可到达阶段；
   可收集阶段；
   终结阶段；
   释放阶段

上面这7个阶段，构成了JVM中对象的完整的生命周期。

(1) 创建阶段

在对象的创建阶段，系统主要通过下面的步骤，完成对象的创建过程：
    
       <1> 为对象分配存储空间；
       <2> 开始构造对象；
       <3> 从超类到子类对static成员进行初始化；
       <4> 超类成员变量按顺序初始化，递归调用超类的构造方法；
       <5> 子类成员变量按顺序初始化，子类构造方法调用。

在创建对象时应注意几个关键应用规则：
      
       <1> 避免在循环体中创建对象，即使该对象占用内存空间不大。
       <2> 尽量及时使对象符合垃圾回收标准。比如 myObject = null。
       <3> 不要采用过深的继承层次。
       <4> 访问本地变量优于访问类中的变量。

(2) 应用阶段

在对象的引用阶段，对象具备如下特征：

<1> 系统至少维护着对象的一个强引用(Strong Reference);
      <2> 所有对该对象的引用全部是强引用(除非我们显示地适用了：软引用(Soft Reference)、弱引用(Weak Reference)或虚引用(Phantom Reference)).

强引用(Strong Reference)：是指JVM内存管理器从根引用集合出发遍历堆中所有到达对象的路径。当到达某对象的任意路径都不含有引用对象时，这个对象的引用就被称为强引用。

软引用(Soft Reference)：软引用的主要特点是有较强的引用功能。只有当内存不够的时候，才回收这类内存，因此内存足够时它们通常不被回收。另外这些引用对象还能保证在Java抛出OutOfMemory异常之前，被设置为null。它可以用于实现一些常用资源的缓存，实现Cache功能，保证最大限度地使用内存你而不引起OutOfMemory。

?

下面是软引用的实现代码：                                 import java.lang.ref.SoftReference;                                 ...                                                                   A a = new A();                                 ...                                 // 使用a                                 ...                                                                    // 使用完了a, 将它设置为soft引用类型，并且释放强引用                                 SoftReference sr = new SoftReference(a);                                 a = null;                                 ...                                 // 下次使用时                     if (sr != null) {                     a = sr.get();                 } else {                     // GC由于低内存，已释放a，因此需要重新装载                                     a = new A();                     sr = new SoftReference(a);                 }

软引用技术的引进使Java应用可以更好地管理内存，稳定系统，防止系统内存溢出，避免系统崩溃。因此在处理一些占用内存较大且生命周期较长，但使用并不繁地对象时应尽量应用该技术。提高系统稳定性。
            
                                     
       弱引用(Weak Reference)：弱应用对象与软引用对象的最大不同就在于：GC在进行垃圾回收时，需要通过算法检查是否回收Soft应用对象，而对于Weak引用，GC总是进行回收。Weak引用对象更容易、更快地被GC回收。Weak引用对象常常用于Map结构中。

?

import java.lang.ref.WeakReference;   4.                               ...   5.                                  6.                               A a = new A();   7.                               ...   8.  9.                               // 使用a   10.                               ...   11.                                   12.                               // 使用完了a, 将它设置为Weak引用类型，并且释放强引用   13.                               WeakReference wr = new WeakReference(a);   14.                               a = null;   15.                               ...   16.  17.                               // 下次使用时   18.                if (wr != null) {   19.                    a = wr.get();   20.            } else {   21.                                   a = new A();   22.                wr = new WeakReference(a);   23.            }

虚引用(Phantom Reference): 虚引用的用途较少，主要用于辅助finalize函数的使用。

虚引用(Phantom Reference)对象指一些执行完了finalize函数，并为不可达对象，但是还没有被GC回收的对象。这种对象可以辅助finalize进行一些后期的回收工作，我们通过覆盖了Refernce的clear()方法，增强资源回收机制的灵活性。

在实际程序设计中一般很少使用弱引用和虚引用，是用软引用的情况较多，因为软引用可以加速JVM对垃圾内存的回收速度，可以维护系统的运行安全，防止内存溢出(OutOfMemory)等问题的产生。

(3) 不可视阶段
         当一个对象处于不可视阶段，说明我们在其他区域的代码中已经不可以在引用它，其强引用已经消失，例如，本地变量超出了其可视
的范围。

?

1.try {   2.            Object localObj = new Object();   3.     localObj.doSomething();   4.      } catch (Exception e) {   5.          e.printStackTrace();   6.      }   7.  8.      if (true) {   9.    // 此区域中localObj 对象已经不可视了, 编译器会报错。   10.    localObj.doSomething();   11.      }

(4) 不可到达阶段
       处于不可达阶段的对象在虚拟机的对象引用根集合中再也找不到直接或间接地强引用，这些对象一般是所有线程栈中的临时变量。所有已经装载的静态变量或者是对本地代码接口的引用。

   (5) 可收集阶段、终结阶段与释放阶段
       当一个对象处于可收集阶段、终结阶段与释放阶段时，该对象有如下三种情况：

<1> 回收器发现该对象已经不可达。

<2> finalize方法已经被执行。

<3> 对象空间已被重用。