Java对象的生命周期与垃圾回收以及四种引用

转载请注明出处: Java对象的生命周期 与 垃圾回收 - ITeye博客 - 老Man


创建对象的方式

  • new语句创建对象。
  • 使用反射,调用java.lang.Class或java.lang.reflect.Constructor的newInstance()实例方法。
  • 调用对象的clone()方法
  • 使用反序列化手段,调用java.io.ObjectInputStream对象的readObject()方法。

 

还有其他一些隐式创建对象的方法:

 

  • 对于java命令中的每个命令行参数,Java虚拟机都会创建相应的String对象,并把它们组织到一个String数组中,再把该数组作为参数传递给程序入口main(String args[])方法。
  • String类型的直接量对应一个String对象。
  • 字符串操作符”+”的运算结果为一个新的String对象。
  • 当JVM加载一个类时,会隐含地创建描述这个类的Class实例。

 

不管采取哪种方式创建对象,JVM创建一个对象都包含以下步骤:

(1) 给对象分配内存。

(2) 将对象的实例变量自动初始化为其类型的默认值。

(3) 初始化对象,给实例变量赋予正确的初始值。

 

 

对于以上第三个步骤,JVM可采用3种方式来初始化对象,到底采用何种初始化方式取决于创建对象的方式。

 

  • 如果对象是通过clone()方法创建的,那么JVM把原来被克隆对象的实例变量的值拷贝到新对象中。
  • 如果对象通过ObjectInputStream类的readObject()方法创建的,那么JVM通过输入流中读入的序列化数据来初始化那些非暂时性的实例变量。
  • 在其他情况下,如果实例变量在声明时被显示初始化,那么就把初始化值赋给实例变量,接着再执行构造方法。这是最简单初始化对象的方式。

 

 

 

 

垃圾回收

Java语言中,内存回收任务由JVM来担当。

在程序的运行环境中,JVM提供了一个系统级的垃圾回收器线程,它负责自动回收那些无用对象所占用的内存。这种内存回收的过程被称为垃圾回收。

 

垃圾回收具有以下优点:

 

  • 程序员从复杂的内存追踪,监测和释放等工作解放出来,减轻程序员进行内存管理的负担。
  • 防止系统内存被非法释放,从而使系统更加健壮和稳定。
  • 只有当对象不再被程序中的任何引用变量引用时,它的内存才可能被回收。
  • 程序无法迫使垃圾回收器立即执行垃圾回收操作。
  • 当垃圾回收器将要回收无用对象的内存时,先调用该对象的finalize()方法,该方法有可能使对象使对象复活,导致垃圾回收器取消回收该对象的内存。

 

 

 

 

 

 

对象的可触及性

在JVM的垃圾回收器来看。堆区中的每个对象都肯能处于以下三个状态之一:

 

  • 可触及状态:当一个对象被创建后,只要程序中还有引用变量引用该对象,那么它就始终处于可触及状态。
  • 可复活状态:当程序不再有任何引用变量引用对象时,它就进入可复活状态。该状态的对象,垃圾回收器会准备释放它占用的内存,在释放前,会调用它的finalize()方法,这些finalize()方法有可能使对象重新转到可触及状态。
  • 不可触及状态:当JVM执行完所有的可复活状态的finalize()方法后,假如这些方法都没有使对象转到可触及状态。那么该对象就进入不可触及状态。只有当对象处于不可触及状态时,垃圾回收器才会真正回收它占用的内存。

 

 

 

 

 

垃圾回收的时间

    当一个对象处于可复活状态时,垃圾回收线程执行它的finalize()方法,任何使它转到不可触及状态,任何回收它占用的内存,这对于程序来说都是透明的。程序只能决定一个对象任何不再被任何引用变量引用,使得它成为可以被回收的垃圾。

 

    类比:居民把无用物品放在指定的地方,清洁工人会把它收拾走。但垃圾被收走的时间,居民是不知道的,也无需了解。

 

    垃圾回收器作为低优先级线程独立运行。在任何时候,程序都无法迫使垃圾回收器立即执行垃圾回收操作。

程序中可调用System.gc()或Runtime.gc()方法提示垃圾回收器尽快执行垃圾回收操作,但是不能保证调用后垃圾回收器会立即执行垃圾回收。

 

    类比:小区垃圾成堆时,居民打电话给环保局,催促清洁工尽快来处理垃圾。但是清洁工不一定立即就来了,也有可能很长时间后再来。

 

 

 

 

 

 

对象的finalize()方法简介

finalize()定义在Object类中:

protected void finalize() throws Throwable

因为该方法为protected,所以任何Java类都可以覆盖finalize()方法,该方法中进行释放对象所占的相关资源的操作。

 

注意:

JVM的垃圾回收操作对程序来说都是透明的。因此程序无法预料某个无用对象的finalize()方法何时被调用。

 

 

finalize()方法的特点:

 

  • 垃圾回收器是否会执行该方法及何时执行该方法,都是不确定的。
  • finalize()方法有可能使对象复活,使它恢复到可触及状态。
  • 垃圾回收器在执行finalize()方法时,如果出现异常,垃圾回收器不会报告异常,程序继续正常运行。

 

 

 

 

 

对象的强,软,弱,虚引用

 

强引用

      如果一个对象具有强引用,垃圾回收器绝不会回收它。当内存空间不足,JVM宁愿抛出OutOfMemoryError错误,使程序异常终止,也不会考随意回收具有强引用的对象来解决内存不足的问题。

 

软引用

    如果一个对象具有软引用。如果内存空间足够。垃圾回收器不会回收它。如果内存不足了,就会回收这些对象的内存。只要垃圾回收器没有回收它,该对象就可以被程序使用。

    软引用可以和一个引用队列(ReferenceQueue)联合使用,如果软引用所引用的对象被垃圾回收,Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

    软引用可用来实现内存敏感的高速缓存。


 

弱引用

    如果一个对象具有弱引用。当垃圾回收器发现只具有弱引用对象,不管当前内存空间足够与否,都会回收它的内存。

不过,由于垃圾回收器是一个优先级很低的线程,因此不一定会很快发现只具有弱引用的对象。

 

 

虚引用

    虚引用不会决定对象的生命周期。如果一个对象仅持有虚引用,那么它就和没有任何引用一样,在任何时候都可能被垃圾回收器回收。虚引用主要用来跟踪对象被垃圾回收的活动。虚引用与软引用和弱引用的一个区别在于:虚引用必须和引用队列(ReferenceQueue)联合使用。当垃 圾回收器准备回收一个对象时,如果发现它还有虚引用,就会在回收对象的内存之前,把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是 否已经加入了虚引用,来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列,那么就可以在所引用的对象的内存被回收之前采取必要的行动。

 

下面这个实验代码很好的探究了四种引用级别对垃圾回收的影响

import java.lang.ref.PhantomReference; //虚引用
import java.lang.ref.ReferenceQueue; //引用队列
import java.lang.ref.SoftReference; //软引用
import java.lang.ref.WeakReference; //弱引用

class Obj 
{
	private final String name;
	public Obj(String name)
	{
		this.name = name;
	}
	
	@Override
	protected void finalize() throws Throwable
	{
		System.out.println("执行finalize方法"+name);
		super.finalize();
	}
}

public class Test
{
	public static void main (String[] args)
	{
//		hardTest();
//		softTest();
//		weakTest();
		phanTest();
	}
	
	public static void hardTest()
	{
		Obj hard = new Obj("hard");
//		hard = null;
		System.gc();
		System.out.println(hard);
	}
	
	public static void softTest()
	{
		SoftReference  soft = new SoftReference(new Obj("soft"));
		System.gc();
		System.out.println(soft.get());
	}
	
	public static void weakTest()
	{
		WeakReference  weak = new WeakReference(new Obj("weak"));
		System.gc();
		System.out.println(weak.get());
	}
	
	public static void phanTest()
	{
		ReferenceQueue rq = new ReferenceQueue();
		PhantomReference phan = new PhantomReference(new Obj("phan"), rq);
		System.out.println(phan.get());
	}
}
 

分别执行四个函数, 并控制强/软引用中的obj是否为null, 共6次实验, 我们可以总结出:

1. 显式的把(强引用)对象置为null,会大大加大 垃圾回收执行频率。几乎只要我们给出建议,jvm就会回收。 

2. 对于软引用,如果不显式的置为null的话,和强引用差不多,垃圾回收不会执行。和强引用的区别是:只会等到内存不足的时候才会执行。 

3. 对于弱引用,就算你不显式的把他置为null,垃圾回收也会立即执行。

4. 虚引用,相当于null。如果一个对象的虚引用加入了引用队列, 那么这个对象行将就木了

你可能感兴趣的:(内存管理)