夯实基础 - java基础学习（对象和垃圾回收）

对象和垃圾回收

Java的垃圾回收时Java语言的重要功能之一。当程序创建对象、数组等引用类型实体时，系统都会在堆内存中为之分配一块内存区，对象就保存在这块内存区中，当这块内存不再被任何引用变量引用时，这块内存就会变成垃圾，等待垃圾回收机制进行回收。垃圾回收机制具有如下特征：

• 垃圾回收机制只负责回收堆内存中的对象，不会回收任何物理资源（例如数据库连接、网络IO等资源）。
• 程序无法精准空着垃圾回收的运行，垃圾回收会在何时的时候运行。当对象永久性地失去引用后，系统就会在合适的时候回收它所占的内存。
• 在垃圾回收机制回收任何对象之前，总会先调用它的finalize（）方法，该方法可能使该对象重新复活（让一个引用变量重新引用该对象），从而导致垃圾回收机制取消回收。

对象在内存中的状态

当一个对象咋堆内存中运行时，根据他被引用变量所引用的状态，可以把它所处的状态分为如下三种。

• 可达状态： 当一个对象被创建后，若有一个以上的引用变量引用它，则这个对象在程序中处于可达状态，程序可通过引用变量来调用该对象的实例变量和方法。
• 可恢复状态：如果程序当中某个对象不再有任何引用变量引用它，它就进入了可恢复状态。在这种状态下，系统的垃圾回收机制准备回收该对象所占用的内存，在回收该对象之前，系统会调用所有可恢复状态对象的finalize()方法进行资源清理。如果系统在调用finalize()方法时重新让一个引用变量引用该对象，则这个对象会再次变为可达状态；否则该对象将进入不可达状态。
• 不可达状态： 当对象与所有引用变量的关联都被切断，且系统已经调用所有对象的finalize()方法后依然没有使该对象变成可达状态，那么这个对象将会永久性的失去引用，最后变成不可达状态。只有当一个对象处于不可达状态时，系统才会真正回收该对象所占有的资源。

下面程序简单的创建了两个字符串对象，并创建了一个引用变量依次指向两个对象。

public class StatusTranfer{
    public static void test() {
        var a = new String("轻量级Java EE企业应用实战");// A
        a = new String("疯狂java讲义");    // B 
    }
    public static void main(String[] args){
        test(); //C 
    }
}

当程序执行test方法的A代码时，代码定义了一个a变量，并让该变量指向了"轻量级Java EE企业应用实战"。因此该字符串对象处于可达状态。

当程序执行test方法的B代码时"疯狂Java讲义"处于可达状态，而“轻量级Java EE企业应用实战”字符串失去了它的引用，所以处于了可恢复状态。

一个对象可以被一个方法的局部变量引用，也可以被其他类的类变量引用，或被其他对象的实例变量引用。当某个对象被其他类的类变量引用时，只有当该对象被销毁之后，该对象才会进入可恢复状态。

强制垃圾回收

当一个对象失去引用之后，系统何时调用它的finalize()方法对它进行资源清理，何时他会变成不可达状态，系统何时回收他所占的内存，对于系统透明。程序只能控制一个对象何时不再被任何引用变量，绝不能控制他何时被回收。

程序无法精准控制Java垃圾回收的时机，但依然可以强制系统进行垃圾回收——这种强制只是通知系统进行垃圾回收，但系统是否进行垃圾回收依然不确定。大部分时候，程序强制系统垃圾回收后总会有一些效果。强制系统垃圾回收有如下两种方式。

• 调用System类的gc()静态方法:System.gc()。
• 调用Runtime对象的gc()实例方法： Runtime.getRuntime().gc().

下面的程序创建了4个匿名对象，每个对象创建之后立即进入可恢复状态，等地系统回收，但是直到程序退出，系统依然不会回收该资源。

public class GcTest{
    public static void main(String[] args){
        for(var i = 1;i < 4; i++){
            new GcTest();
        }
    }
    public void finalize(){
        System.out.println("系统正在清理GCtest对象的资源。。。")
    }
}

编译、运行上面的程序，看不到任何的输出，可见直到系统退出，系统都不曾调用GcTest对象的finalize()方法。但如果将程序修改成如下形式：

public class GcTest{
    public static void main(String[] args){
        for(var i = 1;i < 4; i++){
            new GcTest();
            //下面两行的代码效果都是一样的
            //System.gc();
            Runtime.getRuntime().gc();
        }
    }
    public void finalize(){
        System.out.println("系统正在清理GCtest对象的资源。。。")
    }
}

上述程序使用了强制垃圾回收，但是这种回收的只是建议系统立即进行垃圾回收，系统完全有可能并不立即进行垃圾回收，垃圾回收机制也不会都程序的建议完全置之不理：垃圾回收机制会在收到通知之后，尽快进行垃圾回收。

finalize方法

在垃圾回收机制回收某个对象所占用的内存的之前，通常要求程序调用适当的方法来清理资源，在没有明确指定清理资源的情况下，Java提供了默认机制来清理该对象的资源，这个机制就是finalize()方法。该方法是定义在Object类里的实例方法，该方法原型为：

protected void finalize() throws Throwable

当finalize方法返回之后，对象消失，垃圾回收机制开始执行。

任何的Java类都可以重写Object类的finalize方法，在该方法中清理该对象所占用的资源。如果程序终止之前始终没有进行垃圾回收，则不会调用失去引用对象的finalize方法来清理资源。垃圾回收机制何时调用finalize方法是完全透明的，只有当程序认为需要更多的额外内存时，垃圾回收机制才会进行垃圾回收。因此，完全有可能出现这样的一种场景：某个失去引用的对象只占用了少量内存，而且程序也没有产生更多内存的需求，那么有可能就不会回收这个对象所占用的内存，所以该对象的finalize方法也不会得到调用。

finalize方法具有如下4个特点：

• 永远不要主动调用某个对象的finalize方法，该方法应交给垃圾回收机制调用。
• finalize方法何时被调用，是否被调用具有不确定性，不要把finalize方法当成一定会被执行的方法。
• 当JVM执行可恢复对象的finalize方法时，可能使该对象或系统中其他的对象重新变成可达状态。
• 当JVM执行finalize方法时出现的异常时，垃圾回收机制不会报告异常，程序继续执行。

由于finalize方法并不一定被执行，所以如果需要清理某个类所打开的资源，则不要放在finalize方法中进行清理。

下面程序将会演示如何在finalize方法里复活自身，并可通过该程序看出垃圾回收的不确定性。

public class FinalizeTest {
    private static FinalizeTest finalizeTest = null;
    public static void main(String[] args) throws Exception {
        new FinalizeTest();
        System.gc();
        System.runFinalization();
        finalizeTest.info();
    }
    public void info()
    {
        System.out.println("test finalize");
    }
    public void finalize(){
        finalizeTest = this;
    }
}

上述程序定义了一个FinalizeTest类，重写了该类大的finalize方法，在该方法中将需要清理掉的可恢复对象重新付给ft引用变量方法，从而让该可恢复对象重新变成可达状态。

对象的软、弱和虚引用

对大部分对象而言，程序里会有一个引用变量引用该对象，这是最常见的引用方式。除此之外，java.lang.ref包下面提供了三个类：SoftReference,PhantomReference和WeakReference，他们分别代表了系统对对象的三种引用方式：软引用、虚引用、和软引用。因此，java语言中对对象的引用有如下四种方式：

1. 强引用（StrongReference）

这是java程序中最常见的引用方式。程序创建一个对象，并把这个对象赋给一个引用变量，程序通过该引用变量来操作实际的对象，前面介绍的对象和数组都采用这种强引用的方式。当一个对象被一个或者一个以上的引用变量所引用的时候，它处于可达状态，不能被系统垃圾回收机制回收，

2. 软引用（SoftReference）

软引用通过需要SoftReference类来实现，当一个对象只用软引用的时候，他有可能被垃圾回收机制回收。对于只有软引用的对象而言，当系统内存空间足够的时候，他不会被系统回收，程序也可以使用该对象：当系统内存空间不足的时候，系统可能会回收它，软引用通常用与对内存敏感的程序当中。

3. 弱引用(WeakReference)

弱引用通过WeakReference类实现，弱引用与软引用很想，但是弱引用的引用级别更低。对于只有弱引用的对象而言，当系统垃圾对象回收机制运行时，不管系统内存是否足够，总会回收该对象所占用的内存。当然并不是说当一个对象只用弱引用时，他就会被立即回收——正如那些失去引用的对象一样，必须等到系统垃圾回收机制运行时才会被回收。

4. 虚引用(PhantomReference)

虚引用通过PhantomReference类实现，虚引用完全类似于没有引用。虚引用对对象本身没有太大影响，对象甚至感觉不到虚引用的存在。如果一个对象只有一个虚引用时，那么他和没有引用的效果大致不同。虚引用主要用于跟踪对象被垃圾回收的状态，虚引用不能单独使用，虚引用必须和引用队列（ReferenceQueue）联合使用。

上面三个引用都包含了一个get()方法，用于获取被他们所引用的对象。