Java内存回收机制

2013/03/14 03:57
阅读数 2.4K

一、Java对象在内存引用状态

内存泄露:程序运行过程中,会不断分配内存空间,那些不再使用的内存空间应该即时回收它们,从而保证系统可以再次使用这些内存,如果存在无用的内存没有被回收回来,这就是内存泄漏.
(1)强引用
  这是java程序中最常见的引用方式,程序创建一个对象,并把这个对象赋给一个引用变量,这个引用变量就是强引用.java程序可通过强引用来访问实际的对象。当一个对象被一个或一个以上的强引用变量引用时,它处于可达状态,它不可能被系统垃圾回收机制回收。
  强引用是Java编程中广泛使用的引用类型,被强引用所引用的Java对象绝不会被垃圾回收机制回收,即使系统内存紧张;即使有些Java对象以后永远也不会被用到,JVM也不会回收被强引用所引用的Java对象.
  由于JVM肯定不会回收强引用所引用的JAVA对象,因此强引用是造成JAVA内存泄漏的主要原因。
    如 ReceiptBean rb=new ReceiptBean(); rb就代表了一种强引用的方式
(2)软引用
  软引用需要通过SoftReference类来实现,当一个对象只具有软引用时,它可能被垃圾回收机制回收。对于只有软引用的对象而言,当系统内存空间足够时,它不会被系统回收,程序也可以使用该对象;当系统内存空间不足时,系统将回收它.
  软引用通常用在对内存敏感的程序中,软引用是强引用很好的替代。对于软引用,当系统内存空间充足时,软引用与强引用没有太大的区别,当系统内存空间不足时,被软引用所引用的JAVA对象可以被垃圾回收机制回收,从而避免系统内存不足的异常.
  当程序需要大量创建某个类的新对象,而且有可能重新访问已创建老对象时,可以充分使用软引用来解决内存紧张的问题。

例如需要访问1000个Person对象,可以有两种方式
方法一
依次创建1000个对象,但只有一个Person引用指向最后一个Person对象
方法二 定义一个长度为1000个的Person数组,每个数组元素引用一个Person对象.

对于方法一,弱点很明显,程序不允许需要重新访问前面创建的Person对象,即使这个对象所占的空间还没有被回收。但已经失去了这个对象的引用,因此也不得不重新创建一个新的Person对象(重新分配内存),而那个已有的Person对象(完整的,正确的,可用的)则只能等待垃圾回收
对于方法二,优势是可以随时重新访问前面创建的每个Person对象,但弱点也有,如果系统堆内存空间紧张,而1000个Person对象都被强引用引着,垃圾回收机制也不可能回收它们的堆内存空间,系统性能将变成非常差,甚至因此内存不足导致程序中止。

  如果用软引用则是一种较好的方案,当堆内存空间足够时,垃圾回收机制不会回收Person对象,可以随时重新访问一个已有的Person对象,这和普通的强引用没有任何区别。但当heap堆内存空间不足时,系统也可以回收软引用引用的Person对象,从而提高程序运行性能,避免垃圾回收.

当程序使用强引用时,无论系统堆内存如何紧张,JVM垃圾回收机制都不会回收被强引用所引用的Java对象,因此最后导致程序因内存不足而中止。但如果把强引用改为软引用,就完成可以避免这种情况,这就是软引用的优势所在.

(3)弱引用
  弱引用与软引用有点相似,区别在于弱引用所引用对象的生存期更短。弱引用通过WeakReference类实现,弱引用和软引用很像,但弱引用的引用级别更低。对于只有弱引用的对象而言,当系统垃圾回收机制运行时,不管系统内存是否足够,总会回收该对象所占用的内存。当然,并不是说当一个对象只有弱引用时,它就会立即被回收,正如那些失去引用的对象一样,必须等到系统垃圾回收机制运行时才会被回收.

总结说明:

1.弱引用具有很大的不确定性,因为每次垃圾回收机制执行时都会回收弱引用所引用的对象,而垃圾回收机制的运行又不受程序员的控制,因此程序获取弱引用所引用的java对象时必须小心空指针异常,通过弱引用所获取的java对象可能是null

2.由于垃圾回收的不确定性,当程序希望从弱引用中取出被引用对象时,可能这个被引用对象已经被释放了。如果程序需要使用被引用的对象,则必须重新创建该对象。

(4)虚引用
  软引用和弱引用可以单独使用,但虚引用不能单独使用,单独使用虚引用没有太大的意义。虚引用的主要作用就是跟踪对象被垃圾回收的状态,程序可以通过检查虚引用关联的引用队列中是否包含指定的虚引用,从而了解虚引用所引用的对象是否将被回收.
  引用队列由java.lang.ref.ReferenceQueue类表示,它用于保存被回收对象的引用。当把软引用,弱引用和引用队列联合使用时,系统回收被引用的对象之后,将会把被回收对象对应的引用添加到关联的引用队列中。与软引用和弱引用不同的是,虚引用在对象被释放之前,将把它对应的虚引用添加到关联的队列中,这使得可以在对象被回收之前采取行动。
虚引用通过PhantomReference类实现,它完全类似于没有引用。虚引用对对象本身没有大的影响,对象甚至感觉不到虚引用的存在。如果一个对象只有一个虚引用,那它和没有引用的效果大致相同。虚引用主要用于跟踪对象被垃圾回收的状态,虚引用不能单独使用,虚引用必须和队列ReferenceQueue联合使用.

二、Java内存泄露

对于c++程序来说,对象占用的内存空间都必须由程序显式回收,如果程序员忘记了回收它们,那它们所占用的内存空间就会产生内存泄漏;对于java程序来说,所有不可达的对象都由垃圾回收机制负责回收,因此程序员不需要考虑这部分的内存泄漏。但如果程序中有一些java对象,它们处于可达状态,但程序以后永远都不会再访问它们,那它们所占用的空间也不会被回收,它们所占用的空间也会产生内存泄漏.

例如:
有ArrayList的长度是4,有四个元素“网”,“络”,“时”,“空”,当我们删除了ArrayList中的"网"这个元素时,它的size等于3,也就是该ArrayList认为自己只有3个元素,因此它永远也不会去访问底层数组的第4个元素。对于程序本身来说,这个对象已经变成了垃圾,但对于垃圾回收机制来说,这个对象依然处于可达状态,因此不会回收它,这就产生了内存泄漏了  

再看下面程序采用基于数组的方式实现了一个Stack,大家可以找找这个程序中的内存泄漏

 


package list;

public class Stack
{
	//存放栈内元素的数组
	private Object[] elementData;
	//记录栈内元素的个数
	private int size = 0;
	private int capacityIncrement;
	//以指定初始化容量创建一个Stack
	public Stack(int initialCapacity){
		elementData = new Object[initialCapacity];
	}
	public Stack(int initialCapacity , int capacityIncrement){
		this(initialCapacity);
		this.capacityIncrement = capacityIncrement;
	}
	//向“栈”顶压入一个元素
	public void push(Object object){
		ensureCapacity();
		elementData[size++] = object;
		// if(size==10) System.out.println("size="+size);
	}
	//出栈
	public Object pop(){
		if(size == 0){
			throw new RuntimeException("空栈异常");
		}
		return elementData[--size];
	}
	public int size(){
		return size;
	}
	//保证底层数组能容纳栈内所有元素
	private void ensureCapacity(){
		//增加堆栈的容量
		if(elementData.length==size){
			Object[] oldElements = elementData;
			int newLength = 0;
			//已经设置capacityIncrement
			if (capacityIncrement > 0){
				newLength = elementData.length + capacityIncrement;
			}else{
				//将长度扩充到原来的1.5倍
				newLength = (int)(elementData.length * 1.5);
			}
			// System.out.println("newLength="+newLength);
			elementData = new Object[newLength];
			//将原数组的元素复制到新数组中
			System.arraycopy(oldElements , 0 , elementData , 0 , size);
		}
	}
	public static void main(String[] args){
		Stack stack = new Stack(10);
		//向栈顶压入10个元素
		for (int i = 0 ; i < 10 ; i++){
			stack.push("元素" + i);
		}
		//依次弹出10个元素
		for (int i = 0 ; i < 10 ; i++){
			System.out.println(stack.pop());
		}
	}
}

 

     前面程序实现了一个简单的Stack,并为这个Stack实现了push(),pop()两个方法,其中pop()方法可能产生内存泄漏。为了说明这个Stack的内存泄漏,程序main方法创建了一个Stack对象,先向该Stack压入10个元素。注意:此时底层elementData的长度为10,每人数组元素都引用一个字符串。
  接下来,程序10次调用pop()方法弹出栈顶元素。注意pop()方法产生的内存泄漏,它只做了两件事:一是修饰Stack的size属性,也就是记录栈内元素减1,二是返回elementData数组中索引为size-1的元素

  也就是说,每调用pop方法一次,Stack会记录该栈的尺寸减1,但未清除elementData数组的最后一个元素的引用,这样就会产生内存泄漏。类似地,也应该按ArrayList类的源代码改写此处pop()方法的源代码,如下所示
public Object pop()
{
if(size == 0)
{
throw new RuntimeException("空栈异常");
}
Object obj=elementData[--size];
//清除最后一个数组元素的引用,避免内存泄漏
elementData[size]=null;
return obj;
}

三、内存管理的小技巧

  尽可能多的掌握Java的内存回收,垃圾回收机制是为了更好地管理JVM的内存,这样才能提高java程序的运行性能。根据前面介绍的内存机制,下面给出java内存管理的几个小技巧。
(1)尽量使用直接量
  当需要使用字符串,还有Byte,Short,Integer,Long,Float,Double,Boolean,Charater包装类的实例时,程序不应该采用new的方式来创建对象,而应该直接采用直接量来创建它们。
例如,程序需要"hello"字符串,应该采用如下代码
String str="hello"'
上面这种方式创建一个"hello"字符串,而且JVM的字符串缓存池还会缓存这个字符串。但如果程序采用
String str=new String("hello");
  此时程序同样创建了一个缓存在字符串缓存池中的"hello"字符串。除此之外,str所引用的String对象底层还包含一个char[]数组,这个char[]数组里依次存放了h,e,l,l.o等字符串。

(2)使用StringBuffer和StringBuilder进行字符串拼接
  如果程序中采用多个String对象进行字符串连接运算,在运行时将生成大量临时字符串,这些字符串会保存在内存中从而导致程序性能下降

(3)尽早释放无用对象的引用
  大部分时候,方法局部引用变量所引用的对象会随着方法结束而变成垃圾,因为局部变量的生存周期很短,当方法运行结束之时,该方法内的局部变量就结束了生命周期。因此,大部分时候程序无需将局部引用变量显式设为null.
但是下面程序中的情形则需显式设为null比较好了

public void info()
{
Object obj=new Objec();
System.out.println(obj.toString());
System.out.println(obj.toString());
obj=null;
//执行耗时,耗内存的操作
//或者调用耗时,耗内存的操作的方法
..
}

  对于上面程序所示的info()方法,如果需要“执行耗时,耗内存的操作”或者"或者调用耗时,耗内存的操作的方法",那么上面程序中显式设置obj=null就是有必要的了。可能的情况是:当程序在“执行耗时,耗内存的操作”或者"或者调用耗时,耗内存的操作的方法",obj之前所引用的对象可能被垃圾加收了。

(4)尽量少用静态变量
  从理论来说,Java对象对象何时被回收由垃圾回收机制决定,对程序员来说是不确定的。由于垃圾回收机制判断一个对象是否是垃圾的唯一标准就是该对象是否有引用变量引用它,因此要尽早释放对象的引用。
  最坏的情况是某个对象被static变量所引用,那么垃圾回收机制通常是不会回收这个对象所占用的内存的。

Class Person
{
static Object obj=new Object();
}
  对于上面的Object对象而言,只要obj变量还引用它,就会不会被垃圾回收机制所回收
Person类所对应的Class对象会常驻内存,直到程序结束,因此obj所引用的Object对象一旦被创建,也会常驻内存,直到程序运行结束。

(5)避免在经常调用的方法,循环中创建Java对象

public class Test
{
public static void main(String[] args)
{
for(int i=0;i<10;i++)
{
Object obj=new Object();
//执行其它操作...
}
}
}

  上面物循环产生了10个对象,系统要不断地为这些对象分配内存空间,执行初始化操作。它们的生存时间并不长,接下来系统又需要回收它们所占用的内存空间是,这种不断分配内存,回收操作中,程序的性能受到了很大的影响。

(6)缓存经常使用的对象
  如果有些对象需要经常使用,可以考虑把这些对象用缓存池保存起来,这样下次需要时就可直接拿出来这些对象来用。典型的缓存池是数据连接池,数据连接池里缓存了大量的数据库连接,每次程序需要访问数据库时都可直接取出数据库连接。
  除此之外,如果系统里还有一些常用的基础信息,比如信息化信息里包含的员工信息,物料信息等,也可以考虑对它们进行缓存。
使用缓存通常有两种方法
1.使用HashMap进行缓存
2.直接使用开源缓存项目。(如OSCache,Ehcahe等)

(7)尽量不要用finalize方法
  在一个对象失去引用之后,垃圾回收器准备回收该对象之前,垃圾回收器会先调用对象的finalize()方法来执行资源清理。出于这种考虑,可能有些开发者会考虑使用finalize()方法来进和清理。
在垃圾回收器本身已经严重制约应用程序性能的情况下,如果再选择使用finalize方法进行资源清理,无疑是一种火上浇油的行为,这将导致垃圾回收器的负担更大,导致程序运行效率更低

(8)考虑使用SoftReference软引用

展开阅读全文
加载中
点击引领话题📣 发布并加入讨论🔥
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部