对象与垃圾回收

/*
程序1
*/
package org.lgy.study.gc;

public class GcTest{
	public static void main(String[] args){
		for(int i = 0; i < 4; i++){
			new GcTest();
		}
	}
	
	public void finalize() throws Throwable{
		System.out.println("finalize...");
	}
}
/*
-verbose:gc选项可以输出垃圾收集的 详细信息。
即使使用 java -verbose:gc org.lgy.study.gc.GcTest 命令运行上面的程序，
程序也不会有任何输出，这是因为从程序开始执行，直至程序结束都没执行垃圾回收。
*/

 

/*
程序2
*/
package org.lgy.study.gc;

public class GcTest{
	public static void main(String[] args){
		for(int i = 0; i < 4; i++){
			new GcTest();
			System.gc();
			/*
			try{
				Thread.sleep(2000);
			}catch(Exception e){
				e.printStackTrace();
			}
			*/
		}
	}
	
	public void finalize() throws Throwable{
		System.out.println("finalize...");
	}
}
/*
-verbose:gc选项可以输出垃圾收集的 详细信息。
使用 java -verbose:gc org.lgy.study.gc.GcTest 命令运行上面的程序，可能的结果：

结果1：
[GC 655K->624K(61440K), 0.0013393 secs]
[Full GC 624K->467K(61440K), 0.0116851 secs]
[GC 467K->563K(61440K), 0.0004788 secs]
[Full GC 563K->467K(61440K), 0.0070315 secs]
[GC 467K->563K(61440K), 0.0004662 secs]
[Full GC 563K->467K(61440K), 0.0068475 secs]
[GC 467K->563K(61440K), 0.0004441 secs]
[Full GC 563K->467K(61440K), 0.0070011 secs]
finalize...

结果2：
[GC 655K->680K(61440K), 0.0013204 secs]
[Full GC 680K->467K(61440K), 0.0124876 secs]
[GC 467K->563K(61440K), 0.0005451 secs]
[Full GC 563K->467K(61440K), 0.0076125 secs]
[GC 467K->563K(61440K), 0.0005278 secs]
[Full GC 563K->467K(61440K), 0.0083511 secs]
[GC 467K->563K(61440K), 0.0005080 secs]
[Full GC 563K->467K(61440K), 0.0080329 secs]

这2种结果的区别在于：
结果1虽然运行了垃圾回收机制，但垃圾回收机制仅仅回收了最后一个垃圾对象所占用的内存空间。
结果2虽然运行了垃圾回收机制，但垃圾回收机制并没有回收任何垃圾对象所占有的内存空间。
出现这2中结果的原因可能是系统剩余的内存空间很够用，没有严重的内存需求，
同时原来的线程需要继续执行，所以即使运行了垃圾回收机制也没有回收垃圾内存。
*/

 

/*
程序3
*/
package org.lgy.study.gc;

public class GcTest{
	public static void main(String[] args){
		for(int i = 0; i < 4; i++){
			new GcTest();
			System.gc();
			System.runFinalization();
			/*
			try{
				Thread.sleep(2000);
			}catch(Exception e){
				e.printStackTrace();
			}
			*/
		}
	}
	
	public void finalize() throws Throwable{
		System.out.println("finalize...");
	}
}
/*
-verbose:gc选项可以输出垃圾收集的 详细信息。
使用 java -verbose:gc org.lgy.study.gc.GcTest 命令运行上面的程序，可能的结果：

[GC 655K->680K(61440K), 0.0013011 secs]
[Full GC 680K->467K(61440K), 0.0121374 secs]
finalize...
[GC 1450K->563K(61440K), 0.0004457 secs]
[Full GC 563K->467K(61440K), 0.0078861 secs]
finalize...
[GC 795K->563K(61440K), 0.0004989 secs]
[Full GC 563K->467K(61440K), 0.0080416 secs]
finalize...
[GC 795K->563K(61440K), 0.0007512 secs]
[Full GC 563K->467K(61440K), 0.0075044 secs]
finalize...

这个程序和程序2相比，仅仅多了System.runFinalization();语句。
System和Runtime类里都提供了一个runFinalization()方法，
可以强制垃圾回收机制调用系统中可恢复对象的finalize方法。
*/

 

/*
程序4
*/
package org.lgy.study.gc;

public class GcTest{
	public static void main(String[] args){
		for(int i = 0; i < 4; i++){
			new GcTest();
			System.gc();
			try{
				Thread.sleep(1000);
			}catch(Exception e){
				e.printStackTrace();
			}
		}
	}
	
	public void finalize() throws Throwable{
		System.out.println("finalize...");
	}
}
/*
-verbose:gc选项可以输出垃圾收集的 详细信息。
使用 java -verbose:gc org.lgy.study.gc.GcTest 命令运行上面的程序，可能的结果：

[GC 655K->584K(61440K), 0.0013026 secs]
[Full GC 584K->467K(61440K), 0.0138399 secs]
finalize...
[GC 1450K->595K(61440K), 0.0006197 secs]
[Full GC 595K->467K(61440K), 0.0084750 secs]
finalize...
[GC 467K->563K(61440K), 0.0005128 secs]
[Full GC 563K->467K(61440K), 0.0081691 secs]
finalize...
[GC 467K->563K(61440K), 0.0004808 secs]
[Full GC 563K->467K(61440K), 0.0073200 secs]
finalize...

这个程序和程序2那个程序相比，仅仅是让当前线程暂停了1秒。
为什么执行结果和程序2不同呢？？
执行完System.gc();之后，程序暂停了。
JVM利用暂停的时间启动了垃圾回收机制，并回收了垃圾内，
（因为在暂停的时间里，没有线程需要执行，所以JVM就启动了垃圾回收机制，并回收了垃圾内）
*/

 

Java垃圾回收机制

Java垃圾回收机制

详细介绍Java垃圾回收机制