对象与垃圾回收
Java的垃圾回收是Java语言的重要功能之一。当程序创建对象、数组等引用类型实体时，系统都会在堆内存中为之分配一块内存区，对象就保存在这块内存区中，当这块内存不再被任何引用变量引用时，这块内存就变成垃圾，等待垃圾回收机制进行回收。垃圾回收机制具有如下特征：
- 垃圾回收机制只负责回收堆内存中的对象，不会回收任何物理资源（例如数据库连接、网络IO等资源）。
- 程序无法精确控制垃圾回收的运行，垃圾回收会在合适的时候进行。当对象永久性地失去引用后，系统就会在合适的时候回收它所占的内存。
- 在垃圾回收机制回收任何对象之前，总会先调用它的finalize()方法，该方法可能使该对象重新复活（让一个引用变量重新引用该对象），从而导致垃圾回收机制取消回收。
对象在内存中的状态
当一个对象在堆内存中运行时，根据它被引用变量所引用的状态，可以把他所处的状态分为吐下三种：
- 可达状态：当一个对象被创建后，若有一个以上的引用变量引用它，则这个对象在程序中处于可达状态，程序可通过引用变量来调用该对象的Field和方法。
- 可恢复状态：如果程序中某个对象不再有任何引用变量引用它，它就进入了可恢复状态。在这种状态下，系统的垃圾回收机制准备回收该对象所占用的内存，在回收该对象之前，系统会调用所有可恢复状态对象的finalize()方法进行资源清理。如果系统在调用finalize()方法时重新让一个引用变量引用该对象，则这个对象会再次变为可达状态；否则该对象将进入不可达状态。
- 不可达状态：当对象与所有引用变量的关联都被切断，且系统已经调用所有对象的finalize()方法后依然没有使该对象变成可达状态，那么这个对象将永久性地失去引用，最后变成不可达状态。只有当一个对象处于不可达状态时，系统才会真正回收该对象所占有的资源。
例如，下面程序简单地创建了两个字符串对象，并创建了一个引用变量以此指向两个对象。
public class StatusTranfer {
public static void test(){
String a=new String("泛泛之素") ; //①
a=new String("ffzs"); //②
}
public static void main(String[] args){
test(); //③
}
}
当程序执行test方法的①代码时，代码定义了一个a变量，并让该变量指向"泛泛之素"字符串，该代码执行结束后，"ffzs"字符串对象处于可达状态。
当程序执行了test方法的②代码后，代码再次定义了"ffzs"字符串对象，并让a变量指向该对象。此时，"泛泛之素"字符串对象处于可恢复状态，而"ffzs"字符串对象处于可达状态。
一个对象可以被一个方法的局部变量引用，也可以被其他类的类变量引用，或被其他对象的实例变量引用。当某个对象被其他类的类变量引用时，只有该类被销毁后，该对象才会进入可恢复状态；当某个对象被其他对象的实例变量引用时，只有当该对象被销毁后，该对象才会进入可恢复状态。
强制垃圾回收
当一个对象失去引用后，系统何时调用他的fianlize（）方法对它进行资源清理，何时它会变成不可达状态，系统何时回收它所占有的内存，对于程序完全透明。程序只能控制一个对象何时不再被任何引用变量引用，绝不能控制它何时被回收。
程序无法精确控制Java垃圾回收的时机，但我们依然可以强制新系统进行垃圾回收——这种强制只是通知系统进行垃圾回收，但系统是否进行垃圾回收依然不确定，强制回收有如下两种方法：
- 调用System类的gc()静态方法：System.gc()
- 调用Runtime对象的gc()实例方法：Runtime.getRuntime().gc()
下面程序创建了4个匿名对象，每个对象创建之后立即进入可恢复状态，等待系统回收，但直到程序退出，系统依然不会回收该资源。
public class GcTest {
public static void main(String[] args){
for (int i=0; i<4 ; i++){
new GcTest();
}
}
public void finalize(){
System.out.println("系统正在清理GcTest对象的资源...");
}
}
编译、运行上面程序，看不到任何输出，可见直到系统退出，系统都不曾调用GcTest对象的finalize()方法。但如果将程序修改成如下形式：
public class GcTest
{
public static void main(String[] args)
{
for (int i=0 ; i < 4; i++)
{
new GcTest();
//下面两行代码的作用完全相同，强制系统进行垃圾回收
System.gc();
Runtime.getRuntime().gc();
}
}
public void finalize()
{
System.out.println("系统正在清理GcTest对象的资源...");
}
}
finalize()方法被调用。
finalize方法
在垃圾回收机制回收某个对象所占用的内存之前，通常要求程序调用适当的方法来清理资源，在没有明确指定清理资源的情况下，Java提供了默认机制来清理该对象的资源，这个机制就是finalize()方法。该方法时定义在Object类里的实例方法，方法原型为：
protected void finalize() throws Throwable
当finalize()方法返回后，对象消失，垃圾回收机制开始执行。方法原型中的throws Throwable表示它可以抛出任何类型的异常。
任何Java类都可以重写Object类的finalize()方法，在该方法中清理该对象占用的资源。如果程序终止之前始终没有进行垃圾回收，则不会调用失去引用对象的finalize()方法来清理资源。垃圾回收机制何时调用对象的finalize()方法是完全透明的，只有当程序认为需要更多的额外内存时，垃圾回收机制才会进行垃圾回收。因此，完全有可能出现这样一种情形：某个失去引用的对象只占用了少量内存，而且系统没有产生严重的内存需求，因此垃圾回收机制并没有试图回收该对象所占用的资源，所以该对象的finalize()方法也不会得到调用。
finalize()方法具有如下4个特点：
- 永远不要主动调用某个对象的finalize()方法，该方法应交给垃圾回收机制调用。
- finalize()方法何时被调用，是否被调用具有不确定性，不要把finalize()方法当成一定会被执行的方法。
- 当JVM执行可恢复对象的finalize()方法时，可能使该对象或系统中其他对象重新变成可达状态。
- 当JVM执行finalize()方法时出现异常时，垃圾回收机制不会报告异常，程序继续执行。
由于finalize()方法并不一定会被执行，因此如果想清理某个类里打开的资源，则不要放在finalize()方法中进行清理，后面会介绍专门用于清理资源的方法。
下面程序演示了如何在finalize方法里复活自身，并可通过该程序看出来垃圾回收的不确定性。
public class FinalizeTest {
private static FinalizeTest ft=null;
public void info(){
System.out.println("测试资源清理的finalize方法");
}
public static void main(String[] args) throws Exception{
//创建FinalizeTest对象立即进入可恢复状态
new FinalizeTest();
// 通知系统进行资源回收
System.gc(); //①
//让程序暂停2秒
Thread.sleep(2000); //②
ft.info();
}
public void finalize()
{
//让ft引用到试图回收的可恢复对象，可恢复对象重新变成可达状态
ft=this;
}
}
上面程序中定义了一个FinalizeTest类，重写了该类的finalize()方法，在该方法中把需要清理的可恢复对象重新赋给ft引用变量，从而让该可恢复对象重新编程可达状态。
。
上面程序中的ain方法创建了一个FinalizeTest类的匿名对象，因为创建后没有把这个对象赋给任何引用变量，所以该对象立即进入可恢复状态。进入可恢复状态后，系统调用①行代码通知系统进行垃圾回收，②行代码强制系统暂停2秒，再次调用ft对象的info方法。编译、运行上面程序，看到ft的info方法被正常执行。
如果删除②行代码，取消让系统暂停2秒。再次编译、运行上面程序会出错，因为程序执行了System.gc();后，系统并未立即进行垃圾回收，否则将会先调用可恢复对象的finalize()方法，也就会让ft引用到堆内存中的FinalizeTest对象，就不会引发空指针异常了。当增加②行代码让系统暂停2秒后，程序暂停了，垃圾回收机制也收到了程序的通知，因此开始进行垃圾回收，也就调用了可恢复对象的finalize()方法，从而让ft引用到堆内存中的FinalizeTest对象。
除此之外，System和Runtime类里都提供了一个runFinalization方法，可以强制垃圾回收机制调用系统中可恢复对象的finalize方法。因此可以将上面程序改写为如下形式：
public class FinalizeTest2
{
private static FinalizeTest2 ft=null;
public void info()
{
System.out.println("测试资源清理的finalize方法");
}
public static void main(String[] args) throws Exception
{
//创建TestFinalize对象立即进入可恢复状态
new FinalizeTest2();
//通知系统进行资源回收
System.gc();
//强制垃圾回收机制调用可恢复对象的finalize方法
Runtime.getRuntime().runFinalization(); //①
System.runFinalization(); //②
ft.info();
}
public void finalize()
{
//让ft引用到试图回收的可恢复对象，即可恢复对象重新变成可达状态
ft=this;
}
}
上面程序不再让系统暂停，而是增加了①行代码，这行代码强制垃圾回收机制调用可恢复对象的finalize()方法。该方法执行结束后，ft将引用到系统试图回收的FinalizeTest2对象，所以上面程序可以正常执行ft的info方法。上面程序中被注释的②行代码与①行代码有相同的功能
对象的软、弱和虚引用
对大部分对象而言，程序里会有一个引用变量引用该对象，这是最常见的引用方式。除此之外，java.lang.ref包下提供了3个类：SoftReference、PhantomReference和WeakReference，它们分别代表了系统对对象的3种引用方法：软引用、虚引用和弱引用。因此，Java语言对对象的引用有下面4种方式：
- 强引用（StrongReference）
这是Java程序中最常见的引用方式。程序创建一个对象，并把这个对象赋给一个引用变量，程序通过该引用变量来操作实际的对象，前面介绍的对象和数组都采用了这种强引用的方式。当一个对象被一个或一个以上的引用变量所引用时，它处于可达状态，不可能被系统垃圾回收机制回收。 - 软引用（SoftReference）
软引用需要通过SoftReference类来实现，当一个对象只有软引用时，它有可能被垃圾回收机制回收。对于只有软引用的对象而言，当系统内存空间足够时，它不会被系统回收，程序也可使用该对象；当系统内存空间不足时，系统可能会回收它。软引用通常用于对内存敏感的程序中。 - 弱引用（WeakReference）
弱引用通过WeakReference类实现，弱引用和软引用很像，但弱引用的引用级别更低。对于只有弱引用的对象而言，当系统垃圾回收机制运行时，不管系统内存是否足够，总会回收该对象所占用的内存。当然，并不是说当一个对象只有弱引用时，它就会立即被回收——正如那些失去引用的对象一样，必须等到系统垃圾回收机制运行时才会被回收。 - 虚引用（PhantomReference）
虚引用通过PhantomReference类实现，虚引用完全类似于没有引用。虚引用对对象本身没有太大影响，对象甚至感觉不到虚引用的存在。如果一个对象只有一个虚引用时，那么它和没有引用的效果大致相同。虚引用主要用于跟踪对象被垃圾回收的状态，虚引用不能单独使用，虚引用必须和引用队列（ReferenceQueue）联合使用。
上面三个引用类都包含了一个get方法，用于获取被它们所引用的对象。
引用队列由java.lang.ref.ReferenceQueue类表示，它用于保存被回收后对象的引用。当联合引用软引用、弱引用和引用队列是，系统在回收被引用的对象之后，将把被回收对象对应的引用添加到关联的引用队列中。与软引用和弱引用不同的是，虚引用在对象被释放之前，将把它对应的虚引用添加到它关联的引用队列中，这使得可以在对象被收回之前采取行动。
软引用和弱引用可以单独使用，但徐引用不能单独使用，单独使用虚引用没有太大的意义。虚引用的主要作用就是跟踪对象被垃圾回收的状态，程序可以通过检查与虚引用关联的引用队列中是否已经包含了该虚引用，从而了解虚引用所引用的对象是否即将被回收。
下面程序示范了弱引用对象被系统垃圾回收的过程：
import java.lang.ref.WeakReference;
public class ReferenceTest
{
public static void main(String[] args)
throws Exception
{
//创建一个字符串对象
String str=new String("疯狂Java讲义");
//创建一个弱引用，让此弱引用引用到"疯狂Java讲义"字符串
WeakReference wr=new WeakReference(str); //①
// 切断str引用和"疯狂Java讲义"字符串之间的引用
str=null; //②
//取出弱引用所引用的对象
System.out.println(wr.get()); //③
// 强制垃圾回收
System.gc();
System.runFinalization();
//再次取出弱引用所引用的对象
System.out.println(wr.get()); //④
}
}
下面程序与上面程序基本相似，只是使用了虚引用来引用字符串对象，虚引用无法获取它引用的对象。下面程序还将虚引用和引用队列结合使用，可以看到被虚引用所引用的对象被垃圾回收后，虚引用将被添加到引用队列中:
import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
public class PhantomReferenceTest
{
public static void main(String[] args)
throws Exception
{
//创建一个字符串对象
String str=new String("疯狂Java讲义");
//创建一个引用队列
ReferenceQueue rq=new ReferenceQueue();
//创建一个虚引用，让此虚引用引用到"疯狂Java讲义"字符串
PhantomReference pr=new PhantomReference (str , rq);
// 切断str引用和"疯狂Java讲义"字符串之间的引用
str=null;
//取出虚引用所引用的对象
//并不能通过虚引用访问被引用的对象，所以此处输出null
System.out.println(pr.get()); //①
// 强制垃圾回收
System.gc();
System.runFinalization();
//垃圾回收之后，虚引用将被放入引用队列中
//取出引用队列中最先进入队列的引用与pr进行比较
System.out.println(rq.poll()==pr); //②
}
}
因为系统无法通过虚引用来获得被引用的对象，所以执行①处的输出语句时，程序将输出null（即使此时并未强制进行垃圾回收）。当程序强制垃圾回收后，只有虚引用引用的字符串对象会被垃圾回收，当被引用的对象被回收后，对应的虚引用将被添加到关联的引用队列中，因而将在②代码处看到输出true。
使用这些引用类可以避免在程序执行期间将对象流在内存中。如果以软引用、弱引用或虚引用的方式引用对象，垃圾收集器就能够随意地释放对象。如果希望尽可能减小程序在其生命周期中所占用的内存大小时，这些引用类就很有用处。
必须指出：要是用这些特殊的引用类，就不能保留对对象的强引用；如果保留了对对象的强引用，就会浪费这些引用类所提供的任何好处。
由于来及回收的不确定性，当程序希望从软、弱引用中取出被引用对象时，可能这个被引用对象已经被释放了。如果程序需要使用那个被引用的对象，则必须重新创建该对象。这个过程可以采用两种风格的代码完成，下面代码显示了一种风格：
//取出弱引用所引用的对象
obj=wr.get();
//如果取出的对象为null
if (obj==null)
{
//重新创建一个新的对象，再次让弱引用去引用该对象
wr=new WeakReference(recreateIt()); //①
// 取出弱引用所引用的对象，将其赋给obj变量
obj=wr.get(); //②
}
...//操作obj对象
//再次切断obj和对象之间的关联
obj=null;
下面代码显示了另一种取出被引用对象的风格：
//取出弱引用所引用的对象
obj=wr.get();
//如果取出的对象为null
if (obj==null)
{
//重新创建一个新的对象，并使用强引用来引用它
obj=recreateIt();
// 取出弱引用所引用的对象，将其赋给obj变量
wr=new WeakReference(obj);
}
...//操作obj对象
//再次切断obj和对象之间的关联
obj=null;
上面两端代码采用的都是伪码，其中recreateIt方法用于生成一个obj对象。这两端代码都是先判断obj对象是否已经被回收，如果已经被回收，则重新创新该对象。如果弱引用引用的对象已经被垃圾回收释放了，则重新创建该对象。但第一段代码存在一定的问题：当if块执行完成后，obj还是有可能为null，因为垃圾回收的不确定性，假设系统在①和②行代码之间进行垃圾回收，则系统会再次将wr所引用的对象回收，从而导致obj依然为null。第二段代码则不会存在这个问题，当if块执行结束后， obj一定不为null。