对象的初始化和回收

        系统生成对象时，会自动为对象分配内存空间，并调用相应的构造函数对其初始化，在对象没有任何引用绑定时，垃圾回收器会周期行扫描内存情况并进行回收。

  • 初始化

        对象的生成和初始化是一体的概念，生成了对象就会对其初始化。Java提供了四种方法生成对象，使用new关键字仅仅是其中一种方法。

        1. 使用new关键字生成对象。

        2. 使用反射机制动态生成对象。利用Class，ClassLoader和Constructor类的方法动态生成对象。详情会在Java反射机制中解释。

        3. 使用克隆生成对象。如果一个类实现了Cloneable接口，这个类的对象可以通过使用clone()方法生成该对象的一份拷贝。

        4. 使用反序列化从流中生成对对象。从磁盘中读取相应的输入流的读取方法来生成新的对象。这个方法将在序列化中详细解释。

  • 回收

        垃圾回收是系统自动完成的。当一个对象不再使用，系统会将引用变量的值赋为null，同时调用对象的finalize()方法销毁对象。

        finalize()是一个被保护的方法，可由子类对其复写，需要注意的是，java机制并不保证该方法一定会被执行，如果向显式调用，可以使用System.gc()，详细信息会在JVM中描述。

Java中的垃圾回收与对象生命周期


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> 对象空间已被重用。