java编程优化-内存管理

[ 2010-05-13 19:34:32.0 | 作者: 随想 类别: 基础强化 ] 来源: 原创     浏览 2311
labels:java编程优化-内存管理 强引用 软引用 弱引用 java中的析构方法 jvm中对象的生命周期 垃圾回收

内存管理

垃圾回收,Jvm中的垃圾对象定义:
理解1:一个对象创建后放置在jvm的堆内存中.当永远不再引用这个对象时,他将被jvm在堆内存中回收,被创建对象不能再生,
同事也没办法通过程序语句释放他们.

理解2：当对象在jvm运行空间中无法通过根集合到达时,这个对象就被称作垃圾对象.
根集合是由类中的静态引用域与本地引用组成的.

jvm中对象的生命周期,分为7个阶段
创建阶段,应用阶段,不可视阶段,不可到达阶段,可收集阶段,终结阶段,释放阶段.

创建对象的几个规则:
	(1) 避免在循环体中创建对象,即使该对象占用内存空间不大.
	for(int i = 0; i < 10000; i++){
		Object obj = new Object();	//应当避免
		System.out.println("obj "+obj);
	}
	
	Object o = null;
	for(int i = 0; i < 100000; i++){
		o = new Object();	//仅在内存中保存一份对象的引用,可取
		System.out.println("obj "+o);
	}	
	-----------------------------------------------------------------------------
	public class demo{
	private List list = new ArrayList();
	public demo(){		
		list = new ArrayList();		//将对象初始化了2次,大大影响效率
	}
}
	
	(2) 尽量及时使对象符合垃圾回收标准
	不要采用过深的继承层次
	访问本地变量优于访问类中变量

强引用
	jvm内存管理器从跟引用集合出发遍寻堆中所有到达对象的路径.当到达某对象的任意路径都不含有引用对象时.被称为强引用.
	
软引用
	主要特点是具备较强的引用功能,只有当内存不够的时候,才会回收这类内存,因此在内存足够的时候,他们通常不被回收.
	另外,这些引用对象还能保证java跑出OutOfMemory异常之前,被设置成null.它可以用于实现一些常用的资源缓存,
	实现Cache的功能.保证最大限度的使用内存不引起OutOfMemory.
	public static void main(String[] args) {		
		A1 a1 = new A1();
		//使用a1
		System.out.println(a1.c);
		System.out.println(a1);
		//使用完a1 将它设置为soft引用类型,并且释放强引用
		java.lang.ref.SoftReference sr = new java.lang.ref.SoftReference(a1);
		a1 = null;
		System.out.println(a1);
		//下次使用的时候
		if(sr != null){
			a1 = (A1) sr.get();
		}else{
			//GC 由于低内存,已经释放a1 因此需要重新装在
			a1 = new A1();
			sr = new java.lang.ref.SoftReference(a1);
		}
		System.out.println(a1);
	}
	
弱引用
	对象与Soft引用对象的最大不同就在于,gc在进行回收时,需要通过算法检查是否回收soft引用对象,
	而对weak引用对象,gc总是进行回收,weak引用对象更容易,更快的呗gc回收.虽然,gc在运行时一定回收
	weak对象,但是复杂关系的weak对象群常常需要好几次gc的运行才能完成.weak引用对象常常用于
	map结构中.引用占用内存空间较大的对象.一旦该对象的强引用为null时,对这个对象引用就不存在了,
	gc能够快速地回收该对象空间.
	public static void main(String[] args) {
		Demo demo = new Demo();
		//使用....
		System.out.println(demo+" "+demo.c);
		//...使用完事将它设置为weak引用类型,并释放强引用
		java.lang.ref.WeakReference wr = new java.lang.ref.WeakReference(demo);
		demo = null;
		
		System.out.println("demo 没了 "+demo);
		
		//...下次使用的时候
		if(wr != null){
			demo = wr.get();
		}else{
			demo = new Demo();
		}
		//再次使用
		System.out.println(demo+" "+demo.c);
		
	}

虚引用	
	用途较少,主要用于辅助finalize函数的使用.
	
强调:
	在实际程序设计中一般很少使用弱引用和虚引用,使用软件的情况较多,这是因为软件引用可以加上jvm
	对内存的回收速度,可以维护系统的运行安全,防止内存溢出(OutOfMemory)等问题产生


不可视阶段
	当一个对象处于不可视阶段,说明我们在其他区域的代码中已经不可以在引用它了,
	强引用已经消失.例如,本地变量超出了可视范围.
	public void pore(){
		if(true){
			Object object = new Object();
			object.getClass();
		}
		if(true){			
			//这个区域对于object对象来说已经是不可视的了.
			//因此下面的代码在编译时就会引发错误
			object.getClass();
		}
	}
	如果一个对象在使用完之后,而且在其可视范围区域不在使用,此时应该主动将其设置为空,
	可以在object.getClass();下行加上object = null;这样一行代码强制将object对象设置为空值.
	这样做的意义在于,可以帮jvm及时地发现这个垃圾对象,并且可以及时地回收该对象所占用
	的系统资源.
	
	
数组空间的申请分为显示申请and隐式申请.
	public static void main(String[] args) {
		int[] as = new int[1024];
		//上面这行代码就是显示的相系统一次性的申请了大小为1kb的整数类型的内存空间
		//如果实际需要放入的字眼不足1024 就会浪费资源应该尽可能的用完就马上体现jvm回收
		
		String[] strs = new String[222222];
		SoftReference sf = new SoftReference(strs);
		//用完.....
		strs = null;				
	}

不要提前创建对象
	尽量在需要的时候在创建对象,重复的分配,构造对象可能会因为垃圾回收做额外的工作,
	降低性能.
	void fn(){
		int i;
		A a = new A();
		// 类A的对象a被创建
		//在判断语句之外并没有应用过a.
		if(true){
			// 类A的对象a再次应用
			a.findMethod();
			...
		}
		...
	}
	
	应该这么写
	void fn(){
		int i;
		...
		if(true){
			A a = new A();
			a.findMethod();
			...			
		}
	}

而在java语言中只有构造的概念,却没有析构的概念,这是因为理论上jvm负责对象的

析构方法,由于在java应用中开发的所有类都为Object的子类,因此用户类都从Object

因此finalize的最后一句通常是super.finalize().通过这种方式买我们可以实现从下到上

<FONT color="#5c585a" face=""">finalize调用.即先释放自身在主机往上释放.

package com.iwgod.chapter02.finalize;

public class A {
	Object a = null;
	public A(){
		a = new Object();
		System.out.println("构建A对象");
	}
	protected void destory(){
		a = null;		
		System.out.println("释放a对象");
	}
	protected void finalize() throws Throwable{
		destory();
		super.finalize();	//递归调用超类的finalize方法
	}
}

package com.iwgod.chapter02.finalize;

public class B extends A {
	String b = null;
	public B(){
		b = "aa";
		System.out.println("构建B对象");
	}
	protected void destory(){
		b = null;
		System.out.println("释放b对象");
		super.destory();
	}
	protected void finalize() throws Throwable{
		destory();
		super.finalize();		
	}
	
}

package com.iwgod.chapter02.finalize;

public class C extends B {
	Object c = null;
	public C(){
		c = new Object();
		System.out.println("创建C对象");
	}
	protected void destory(){
		c = null;
		System.out.println("释放c对象");
		super.destory();
	}
	protected void finalize() throws Throwable{
		destory();
		super.finalize();
	}
}

package com.iwgod.chapter02.finalize;

public class Test {

	/**
	 * @param args
	 * @throws Throwable 
	 */
	public static void main(String[] args) throws Throwable {
		// TODO Auto-generated method stub
		C c = new C();
		c.destory();
	}
	/**
	 * 注意到test类中实例化C对象的时候,其构造器产生了递归调用,并且是由几类开始
	 * 一次调用,初始化成员对象,而当调用c类的destory方法时系统通用产生了递归调用
	 * 但调用的顺序恰好相反.释放资源由子类开始,
	 * 由此可见我们在设计类时尽量避免在类的默认构造器中创建,初始化大量的对象,防止在调用其自身的构造器
	 * 时造成不必要的内存浪费,因为即使我们没有像调用父类的构造器创建大量无用的对象,但是喜用都会自动去
	 * 创建它们,而这些操作都是隐含的
	 */

}