垃圾回收机制与引用类型

  1. 云栖社区>
  2. 博客>
  3. 正文

垃圾回收机制与引用类型

一叶飘舟 2012-09-07 17:59:00 浏览1213 评论0

摘要:  Java语言的一个重要特性是引入了自动的内存管理机制,这样一来,开发人员就不需要自己来管理应用中的内存了。C/C++开发人员需要通过malloc/free和new/delete等函数来显式的分配和释放内存。

 Java语言的一个重要特性是引入了自动的内存管理机制,这样一来,开发人员就不需要自己来管理应用中的内存了。C/C++开发人员需要通过malloc/free和new/delete等函数来显式的分配和释放内存。这对开发人员提出了比较高的要求,因为这些方法使用不当很容易造成内存访问错误和内存泄露等严重问题。一个最常见的问题是 “悬挂引用(dangling references)”,即一个引用或指针所指向的内存区块已经被错误的回收并重新分配给新的对象了,如果程序继续使用这个引用或指针的话会,必然会造成不可预期的结果。开发人员有可能忘记显式地调用内存释放的函数而造成内存泄露。而自动的内存管理则是把管理内存的任务交给编程语言的运行环境来负责。开发人员并不需要关心内存的分配与回收的底层细节。Java平台通过垃圾回收器(GC)来进行自动的内存管理。

一、JAVA的垃圾回收机制

        Java的垃圾回收器要负责完成三件任务:

        1、分配内存
        2、确保被引用的对象的内存不被错误回收
        3、回收不再被引用的对象的内存空间

        垃圾回收是一个复杂而且耗时的操作,如果JVM(Java虚拟机)花费过多的时间在垃圾回收上,则势必会影响应用的运行性能。一般情况下,当垃圾回收器在进行回收操作的时候,整个应用的执行是被暂时中止(stop-the-world)的。这是因为垃圾回收器需要更新应用中所有对象引用的实际内存地址。

        不同的硬件平台所能支持的垃圾回收方式也不同。比如在多CPU的平台上,就可以通过并行的方式来回收垃圾。而单CPU平台则只能串行进行。不同的应用所期望的垃圾回收方式也会有所不同。服务器端应用可能希望在应用的整个运行时间中,花在垃圾回收上的时间总数越小越好。而对于与用户交互的应用来说,则可能希望所垃圾回收所带来的应用停顿的时间间隔越小越好。对于不同的情况,JVM(Java虚拟机)中提供了多种垃圾回收方法以及对应的性能调优参数,应用可以根据需要来进行定制。

        Java 垃圾回收机制最基本的做法是分代回收。内存区域被划分成不同的代,对象根据其存活的时间被保存在对应代的区域中。一般的实现是划分成3个代:年轻、年老和永久。内存的分配是发生在年轻代中。当一个对象存活时间足够长的时候,它就会被复制到年老代中。对于不同的代可以使用不同的垃圾回收算法。进行分代回收的出发点是对应用中对象存活时间进行研究之后得出的统计规律。一般来说,一个应用中的大部分对象的存活时间都很短。比如局部变量的存活时间就只在方法的执行过程中。基于这一点,对于年轻代的垃圾回收算法就可以很有针对性。

        年轻代的内存区域被进一步划分成Eden区和两个Survivor区(存活区)。Eden区是进行内存分配的地方,是一块连续的空闲内存区域。在上面的进行内存分配速度非常快,因为不需要进行可用内存块的查找。两个Survivor区中始终有一个是空白的。在进行垃圾回收的时候,Eden区和其中一个非空Survivor区中还存活的对象,根据其存活时间被复制到当前空白的Survivor区或年老代中。经过这一次的复制之后,之前非空的Survivor区中包含了当前还存活的对象,而Eden区和另一个Survivor区中的内容已经不再需要了,只需要简单地把这两个区域清空即可。下一次垃圾回收的时候,这两个Survivor区的角色就发生了交换。一般来说,年轻代区域较小,而且大部分对象都已经不再存活,因此在其中查找存活对象的效率较高。

        而对于年老和永久代的内存区域,则采用的是不同的回收算法,称为“标记-清除-压缩(Mark-Sweep-Compact)”法。标记的过程是找出当前还存活的对象,并进行标记;清除则是遍历整个内存区域,找出其中需要进行回收的区域;而压缩则是把存活对象的内存移动到整个内存区域的一端,使得另一端是一块连续的空闲区域,方便进行内存分配和复制。

        Java中提供了4种不同的垃圾回收机制。最常用的是串行回收方式,即使用单个CPU回收年轻和年老代的内存。在回收的过程中,应用程序被暂时中止。回收方式使用的是上面提到的最基本的分代回收。串行回收方式适合于一般的单CPU桌面平台。如果是多CPU的平台,则适合的是并行回收方式。这种方式在对年轻代进行回收的时候,会使用多个CPU来并行处理,可以提升回收的性能。并发标记-清除回收方式适合于对应用的响应时间要求比较高的情况,即需要减少垃圾回收所带来的应用暂时中止的时间。这种做法的优点在于可以在应用运行的同时标记存活对象与回收垃圾,而只需要暂时中止应用比较短的时间。

二、JAVA引用类型

        如果一个内存中的对象没有任何引用的话,就说明这个对象已经不再被使用了,从而可以成为被垃圾回收的候选。不过,由于垃圾回收器的运行时间不确定,所以可被垃圾回收的对象的实际被回收时间是不确定的。对于一个对象来说,只要有引用的存在,它就会一直存在于内存中。如果这样的对象越来越多,超出了JVM中的内存总数,JVM就会抛出OutOfMemory错误。

        虽然垃圾回收的具体运行是由JVM来控制的,但是开发人员仍然可以在一定程度上与垃圾回收器进行交互,其目的在于更好的帮助垃圾回收器管理好应用的内存。

        在Java中把对象的引用分为 4 种级别,从而使程序能更加灵活地控制对象的生命周期。这 4 种级别由高到低依次为:强引用、软引用、弱引用和虚引用。

        JAVA对象引用类层次结构图如下图所示:

 
图14-1  JAVA对象引用类层次结构图

        1)强引用类型

        在一般的Java程序中,见到最多的就是强引用(strong reference)。如我们最常见的代码
//变量定义
String str = “Hello Wolrd”;
		Object obj = new Object();
		Date date = new Date(),

在上面的代码中str、obj、date都是对象的强引用。对象的强引用可以在程序中到处传递。很多情况下,会同时有多个引用指向同一个对象。强引用的存在限制了对象在内存中的存活时间。假如对象A中包含了一个对象B的强引用,那么一般情况下,对象B的存活时间就不会短于对象A。如果对象A没有显式的把对象B的引用设为null的话,就只有当对象A被垃圾回收之后,对象B才不再有引用指向它,才可能获得被垃圾回收的机会。

        2)软引用类型

        软引用(soft reference)在强度上弱于强引用,通过SoftReference类来表示。它的作用是告诉垃圾回收器,程序中的哪些对象并不那么重要,当内存不足的时候是可以被暂时回收的。当JVM中的内存不足的时候,垃圾回收器会释放那些只被软引用所指向的对象。如果全部释放完这些对象之后,内存还不足,才会抛出Out Of Memory错误。

        软引用非常适合于创建缓存。当系统内存不足的时候,缓存中的内容是可以被释放的。比如考虑一个图像编辑器的程序,该程序会把图像文件的全部内容都读取到内存中,以方便进行处理,而用户也可以同时打开多个文件。当同时打开的文件过多的时候,就可能造成内存不足。如果使用软引用来指向图像文件内容的话,垃圾回收器就可以在必要的时候回收掉这些内存。

        从下面的Java代码中可以看到软引用类型的使用方法。
public class BitmapCache {
   		private String url;//图片URL
   		private SoftReference<Bitmap> softRef;// //软引用-只有当系统内存不足的时候才去释放
	public BitmapCache (String url) {
      		 this. url = url;
		 softRef = new SoftReference< Bitmap >(null);
  		}
  		private Bitmap loadRemoteBitmap() {
		final DefaultHttpClient client = new DefaultHttpClient(); 
		final HttpGet getRequest = new HttpGet(url);
		HttpResponse response = client.execute(getRequest);
		final int statusCode = response.getStatusLine().getStatusCode();
		final HttpEntity entity = response.getEntity();
		InputStream inputStream = entity.getContent();
		final ByteArrayOutputStream dataStream = new ByteArrayOutputStream();
		OutputStream outputStream = new BufferedOutputStream(dataStream, IO_BUFFER_SIZE);
		copy(inputStream, outputStream);
		outputStream.flush();
		final byte[] data = dataStream.toByteArray();
		final Bitmap bitmap = BitmapFactory.decodeByteArray(data, 0,  data.length);
      		return bitmap; 
		}
  		public Bitmap get Bitmap () {
       		Bitmap bitmap = softRef.get();
     	 	if (bitmap == null) {//系统内存不足的时,图片已经被释放需要重新加载网络图片
          		bitmap = loadRemoteBitmap ();
           		softRef = new SoftReference< Bitmap >( bitmap);
     		}
     		return bitmap;
   		}
}

在使用上面程序的时候,由于软引用所指向的对象可能被回收掉,在通过get方法来获取软引用所实际指向的对象的时候,总是要检查该对象是否还存活。

        3)弱引用类型

        弱引用(weak reference)在强度上弱于软引用,通过WeakReference类来表示。它的作用是引用一个对象,但是并不阻止该对象被回收。如果使用一个强引用的话,只要该引用存在,那么被引用的对象是不能被回收的,弱引用则没有这个问题。在垃圾回收器运行的时候,如果一个对象的所有引用都是弱引用的话,该对象会被回收。弱引用的作用在于解决强引用所带来的对象之间在存活时间上的耦合关系。

        弱引用最常见的用处是在集合类中,尤其在哈希表中。哈希表的接口允许使用任何Java对象作为键(Key)。当一个键值对(Key-Value)被放入到哈希表中之后,哈希表对象本身就有了对这些键和值对象的引用。如果这种引用是强引用的话,那么只要哈希表对象本身还存活,其中所包含的键和值对象是不会被回收的。如果某个存活时间很长的哈希表中包含的键值对很多,最终就有可能消耗掉JVM中全部的内存。对于这种情况的解决办法就是使用弱引用来引用这些对象,这样哈希表中的键和值对象都能被垃圾回收器及时回收。在Java中可以使用WeakHashMap类来满足这一常见需求。

        4)虚引用类型

        在介绍虚引用之前,先要了解一下Java提供的对象终止化机制(finalization)。

        在Object类里面有个finalize方法,其设计的初衷是在一个对象被真正回收之前,可以用来执行一些清理的工作。因为Java并没有提供类似C++的析构函数一样的机制,只是简单地通过 finalize方法来实现。但是问题在于垃圾回收器的运行时间是不固定的,所以这些清理工作的实际运行时间也是不能预知的。

        使用虚引用(phantom reference)可以解决这个问题。在创建虚引用PhantomReference的时候必须要指定一个引用队列。当一个对象的finalize方法已经被调用了之后,这个对象的虚引用会被加入到队列中。通过检查该队列里面的内容就知道一个对象是不是已经准备要被回收了。

        虚引用及其队列的使用情况并不多见,主要用来实现比较精细的内存使用控制,这对于移动设备来说是很有意义的。程序可以在确定一个对象要被回收之后,再申请内存创建新的对象。通过这种方式可以使得程序所消耗的内存维持在一个相对较低的数量。

        比如下面的Java代码给出了一个缓冲区的实现示例。
//虚引用实例代码
public class PhantomBuffer {
//缓冲区字节数组
private byte[] data = new byte[0];
//引用队列
private ReferenceQueue<byte[]> queue = new ReferenceQueue<byte[]>();
//虚引用
private PhantomReference<byte[]> ref = new PhantomReference<byte[]>(data, queue);
//生成指定大小的缓冲区
public byte[] get(int size) {
	    //校验size是否合法
        if (size <= 0) {
            // size不合法,抛出异常
            throw new IllegalArgumentException("Wrong buffer size");
        }
	    //检查当前缓冲区是否能满足申请的缓冲区大小
        if (data.length < size) {
            data = null;
		   //强制运行垃圾回收器
            System.gc();
             try {
			  //该方法会阻塞直到队列非空
                queue.remove();
			  //虚引用不会自动清空,要手动运行
                ref.clear();
                ref = null;
			  //创建新的缓冲区
                data = new byte[size];
			  //创建虚引用,并加入到应用队列
                ref = new PhantomReference<byte[]>(data, queue);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
       }
       return data;
    }
}

在上面的代码中,每次申请新的缓冲区的时候,都首先确保之前的缓冲区的字节数组已经被成功回收。引用队列的remove方法会阻塞直到新的虚引用被加入到队列中。需要注意的是,这种做法会导致垃圾回收器被运行的次数过多,可能会造成程序的吞吐量过低。

        5)引用队列

        在有些情况下,程序会需要在一个对象的可达到性发生变化的时候得到通知。比如某个对象的强引用都已经不存在了,只剩下软引用或是弱引用。但是还需要对引用本身做一些的处理。典型的情景是在哈希表中,引用对象是作为WeakHashMap中的键对象的,当其引用的实际对象被垃圾回收之后,就需要把该键值对从哈希表中删除。有了引用队列(ReferenceQueue),就可以方便的获取到这些弱引用对象,将它们从表中删除。在软引用和弱引用对象被添加到队列之前,其对实际对象的引用会被自动清空。通过引用队列的poll/remove方法就可以分别以非阻塞和阻塞的方式获取队列中的引用对象。

【云栖快讯】一站式开发者服务,海量学习资源免费学  详情请点击

网友评论