最近有位细心的朋友在阅读笔者的文章时,对java类的生命周期问题有一些疑惑,笔者打开百度搜了一下相关的问题,看到网上的资料很少有把这个问题讲明白的,主要是因为目前国内java方面的教材大多只是告诉你“怎样做”,但至于“为什么这样做”却不多说,所以造成大家在基础和原理方面的知识比较匮乏,所以笔者今天就斗胆来讲一下这个问题,权当抛砖引玉,希望对在这个问题上有疑惑的朋友有所帮助,文中有说的不对的地方,也希望各路高手前来指正。
首先来了解一下jvm(java虚拟机)中的几个比较重要的内存区域,这几个区域在java类的生命周期中扮演着比较重要的角色:
除了以上四个内存区域之外,jvm中的运行时内存区域还包括本地方法栈和程序计数器,这两个区域与java类的生命周期关系不是很大,在这里就不说了,感兴趣的朋友可以自己百度一下。
当我们编写一个java的源文件后,经过编译会生成一个后缀名为class的文件,这种文件叫做字节码文件,只有这种字节码文件才能够在java虚拟机中运行,java类的生命周期就是指一个class文件从加载到卸载的全过程。
一个java类的完整的生命周期会经历加载、连接、初始化、使用、和卸载五个阶段,当然也有在加载或者连接之后没有被初始化就直接被使用的情况,如图所示:
下面我们就依次来说一说这五个阶段。
加载
在java中,我们经常会接触到一个词——类加载,它和这里的加载并不是一回事,通常我们说类加载指的是类的生命周期中加载、连接、初始化三个阶段。在加载阶段,java虚拟机会做什么工作呢?其实很简单,就是找到需要加载的类并把类的信息加载到jvm的方法区中,然后在堆区中实例化一个java.lang.Class对象,作为方法区中这个类的信息的入口。
类的加载方式比较灵活,我们最常用的加载方式有两种,一种是根据类的全路径名找到相应的class文件,然后从class文件中读取文件内容;另一种是从jar文件中读取。另外,还有下面几种方式也比较常用:
对于加载的时机,各个虚拟机的做法并不一样,但是有一个原则,就是当jvm“预期”到一个类将要被使用时,就会在使用它之前对这个类进行加载。比如说,在一段代码中出现了一个类的名字,jvm在执行这段代码之前并不能确定这个类是否会被使用到,于是,有些jvm会在执行前就加载这个类,而有些则在真正需要用的时候才会去加载它,这取决于具体的jvm实现。我们常用的hotspot虚拟机是采用的后者,就是说当真正用到一个类的时候才对它进行加载。
加载阶段是类的生命周期中的第一个阶段,加载阶段之后,是连接阶段。有一点需要注意,就是有时连接阶段并不会等加载阶段完全完成之后才开始,而是交叉进行,可能一个类只加载了一部分之后,连接阶段就已经开始了。但是这两个阶段总的开始时间和完成时间总是固定的:加载阶段总是在连接阶段之前开始,连接阶段总是在加载阶段完成之后完成。
连接
连接阶段比较复杂,一般会跟加载阶段和初始化阶段交叉进行,这个阶段的主要任务就是做一些加载后的验证工作以及一些初始化前的准备工作,可以细分为三个步骤:验证、准备和解析。
连接阶段完成之后会根据使用的情况(直接引用还是被动引用)来选择是否对类进行初始化。
初始化
如果一个类被直接引用,就会触发类的初始化。在java中,直接引用的情况有:
除了以上四种情况,其他使用类的方式叫做被动引用,而被动引用不会触发类的初始化。请看主动引用的示例代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
import
java.lang.reflect.Field;
import
java.lang.reflect.Method;
class
InitClass{
static
{
System.out.println(
"初始化InitClass"
);
}
public
static
String a =
null
;
public
static
void
method(){}
}
class
SubInitClass
extends
InitClass{}
public
class
Test1 {
/**
* 主动引用引起类的初始化的第四种情况就是运行Test1的main方法时
* 导致Test1初始化,这一点很好理解,就不特别演示了。
* 本代码演示了前三种情况,以下代码都会引起InitClass的初始化,
* 但由于初始化只会进行一次,运行时请将注解去掉,依次运行查看结果。
* @param args
* @throws Exception
*/
public
static
void
main(String[] args)
throws
Exception{
// 主动引用引起类的初始化一: new对象、读取或设置类的静态变量、调用类的静态方法。
// new InitClass();
// InitClass.a = "";
// String a = InitClass.a;
// InitClass.method();
// 主动引用引起类的初始化二:通过反射实例化对象、读取或设置类的静态变量、调用类的静态方法。
// Class cls = InitClass.class;
// cls.newInstance();
// Field f = cls.getDeclaredField("a");
// f.get(null);
// f.set(null, "s");
// Method md = cls.getDeclaredMethod("method");
// md.invoke(null, null);
// 主动引用引起类的初始化三:实例化子类,引起父类初始化。
// new SubInitClass();
}
}
|
上面的程序演示了主动引用触发类的初始化的四种情况。
类的初始化过程是这样的:按照顺序自上而下运行类中的变量赋值语句和静态语句,如果有父类,则首先按照顺序运行父类中的变量赋值语句和静态语句。先看一个例子,首先建两个类用来显示赋值操作:
1
2
3
4
5
6
7
8
9
10
|
public
class
Field1{
public
Field1(){
System.out.println(
"Field1构造方法"
);
}
}
public
class
Field2{
public
Field2(){
System.out.println(
"Field2构造方法"
);
}
}
|
下面是演示初始化顺序的代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
class
InitClass2{
static
{
System.out.println(
"运行父类静态代码"
);
}
public
static
Field1 f1 =
new
Field1();
public
static
Field1 f2;
}
class
SubInitClass2
extends
InitClass2{
static
{
System.out.println(
"运行子类静态代码"
);
}
public
static
Field2 f2 =
new
Field2();
}
public
class
Test2 {
public
static
void
main(String[] args)
throws
ClassNotFoundException{
new
SubInitClass2();
}
}
|
上面的代码中,初始化的顺序是:第03行,第05行,第11行,第13行。第04行是声明操作,没有赋值,所以不会被运行。而下面的代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
class
InitClass2{
public
static
Field1 f1 =
new
Field1();
public
static
Field1 f2;
static
{
System.out.println(
"运行父类静态代码"
);
}
}
class
SubInitClass2
extends
InitClass2{
public
static
Field2 f2 =
new
Field2();
static
{
System.out.println(
"运行子类静态代码"
);
}
}
public
class
Test2 {
public
static
void
main(String[] args)
throws
ClassNotFoundException{
new
SubInitClass2();
}
}
|
初始化顺序为:第02行、第05行、第10行、第12行,各位可以运行程序查看结果。
在类的初始化阶段,只会初始化与类相关的静态赋值语句和静态语句,也就是有static关键字修饰的信息,而没有static修饰的赋值语句和执行语句在实例化对象的时候才会运行。
使用
类的使用包括主动引用和被动引用,主动引用在初始化的章节中已经说过了,下面我们主要来说一下被动引用:
被动引用的示例代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
class
InitClass{
static
{
System.out.println(
"初始化InitClass"
);
}
public
static
String a =
null
;
public
final
static
String b =
"b"
;
public
static
void
method(){}
}
class
SubInitClass
extends
InitClass{
static
{
System.out.println(
"初始化SubInitClass"
);
}
}
public
class
Test4 {
public
static
void
main(String[] args)
throws
Exception{
// String a = SubInitClass.a;// 引用父类的静态字段,只会引起父类初始化,而不会引起子类的初始化
// String b = InitClass.b;// 使用类的常量不会引起类的初始化
SubInitClass[] sc =
new
SubInitClass[
10
];
// 定义类数组不会引起类的初始化
}
}
|
最后总结一下使用阶段:使用阶段包括主动引用和被动引用,主动饮用会引起类的初始化,而被动引用不会引起类的初始化。
当使用阶段完成之后,java类就进入了卸载阶段。
卸载
关于类的卸载,笔者在单例模式讨论篇:单例模式与垃圾回收一文中有过描述,在类使用完之后,如果满足下面的情况,类就会被卸载:
如果以上三个条件全部满足,jvm就会在方法区垃圾回收的时候对类进行卸载,类的卸载过程其实就是在方法区中清空类信息,java类的整个生命周期就结束了。
做java的朋友对于对象的生命周期可能都比较熟悉,对象基本上都是在jvm的堆区中创建,在创建对象之前,会触发类加载(加载、连接、初始化),当类初始化完成后,根据类信息在堆区中实例化类对象,初始化非静态变量、非静态代码以及默认构造方法,当对象使用完之后会在合适的时候被jvm垃圾收集器回收。读完本文后我们知道,对象的生命周期只是类的生命周期中使用阶段的主动引用的一种情况(即实例化类对象)。而类的整个生命周期则要比对象的生命周期长的多。
如果有疑问或者发现本文中不对的地方,欢迎各位留言。本文doc文档版本的下载地址:
csdn资源:http://download.csdn.net/detail/zhengzhb/4260878
百度文库:http://wenku.baidu.com/view/5d2c8b6858fafab069dc023d.html?st=1