【Java】-NO.16.EBook.4.Java.1.006-【疯狂Java讲义第3版 李刚】- 垃圾回收

1.0.0 Summary

Tittle：【Java】-NO.16.EBook.4.Java.1.006-【疯狂Java讲义第3版 李刚】- 垃圾回收

Style：EBook

Series：Java

Since：2017-09-18

End：....

Total Hours：...

Degree Of Diffculty：2

Degree Of Mastery：2

Practical Level：2

Desired Goal：2

Archieve Goal：....

Gerneral Evaluation：...

Writer:kingdelee

Related Links：

http://www.cnblogs.com/kingdelee/

1.堆内存与垃圾回收

创建的对象、数组等引用的实体时，在堆内存分配空间将其存储。当这些对象不再被引用时，会被垃圾回收。

2.垃圾回收特点

只回收对象，不回收物理资源（数据库链接、网络IO等资源）。

不确定性。

3.finalize()

回收对象前，总会调用对象的finalize()方法，该方法可能使该对象重新复活（让另一个引用变量引用该对象），从而导致垃圾回收机制取消回收。

4.对象在内存中的状态

可达状态：对象被引用时的状态

可恢复状态：不再被引用时的状态。这种状态系统会调用有可恢复状态对象的finalize()方法进行资源情理。该对象要么重新被引用进入可达状态，要么被进入不可达状态。

不可达状态：不再被引用，且已经调用过finalize()方法也没变成可达状态，则变成不可达状态。会被垃圾回收。

5.强制进行垃圾回收：

System.gc()

Runtime.getRuntime().gc()

// 当把#1 #2 #3都开启的时候。系统执行gc，需要执行Runtime.getRuntime().runFinalization(); System.runFinalization()主动通知才会调用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();  //#1
        // 强制垃圾回收机制调用可恢复对象的finalize()方法
		Runtime.getRuntime().runFinalization();   //#2
        System.runFinalization();   //#3
        ft.info();
    }

    public void finalize() {
        // 让tf引用到试图回收的可恢复对象，即可恢复对象重新变成可达
        ft = this;
    }
}

　　

6. 对象的强引用、软引用、弱引用、虚引用

强引用(StrongReference)：

　　对象被引用，可达状态，不可能被回收。

软引用(SoftReference)：

　　对象只有软引用时，可能被回收（内存不足时回收）。

弱引用(WeakReference)：

　　对象只有弱引用时，内存无论是否足够，只有在GC时一定会被回收。

虚引用(PhatomReference)：

　　虚引用近乎于未被引用。主要用于跟踪对象被回收的状态，必须和引用队列（ReferenceQueue）联合使用。

// 1. 当对象放在弱引用中时，即便对象被赋值为null，依旧可以通过弱引用的.get()取出，直到执行GC才回收。
// 1.1 注意，使用String str = "java";这种形式，字符串常量池会管理这个对象，强引用，就不会被GC了
// 2. 使用软引用、弱引用、虚引用引用对象，gc就可以随意的释放对象。而使用强引用，这没有这种好处。
// 3.将被GC的弱引用重新创建
public class ReferenceTest
{
    public static void main(String[] args)
		throws Exception
	{
		// 创建一个字符串对象
//		String str = new String("Java");
		// 1.1 注意，使用String str = "java";这种形式，字符串常量池会管理这个对象，强引用，就不会被GC了，也还是能够get()出来
		String str = "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());  //④
	}

	@Test
	public void t1(){
		String str = new String("Java");
		// 创建一个弱引用，让此弱引用引用到"疯狂Java讲义"字符串
		WeakReference wr = new WeakReference(str);  //①
		// 切断str引用和"疯狂Java讲义"字符串之间的引用
		str = null;   //②
		// 取出弱引用所引用的对象
		System.out.println(wr.get());  //③

		//
		Object obj = wr.get();
		if(obj == null){
			// 3.将被GC的弱引用重新创建
			wr = new WeakReference(new String("Java"));
			obj = wr.get();
		}

		// 强制垃圾回收
		System.gc();
		System.runFinalization();
		// 再次取出弱引用所引用的对象
		System.out.println(wr.get());  //④
	}
}

　　

// 1.虚引用近乎于未被引用，故无法从虚引用中get()出对象，可以通过poll()获取对象信息
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
		// 1.虚引用近乎于未被引用，故无法从虚引用中get()出对象，可以通过poll()获取对象信息
		System.out.println(pr.get());  //①
		// 强制垃圾回收
		System.gc();
		System.runFinalization();
		// 垃圾回收之后，虚引用将被放入引用队列中
		// 取出引用队列中最先进入队列中的引用与pr进行比较
		System.out.println(rq.poll() == pr);   //②
	}
}