类加载机制+变量初始化
字节码class文件、可执行代码、机器码的生成与执行:
1)编译器将Java源代码编译成字节码class文件
2)类加载到JVM里面后,执行引擎把字节码转为可执行代码
3)执行的过程,再把可执行代码转为机器码,由底层的操作系统完成执行。
运行Java的几个命令:
1)java用来运行一个.class文件
2)javadoc用来生成api文档
3)jar用来生成jar包
4)javac用来把.java文件编译为.class文件
类从加载到虚拟机内存中开始,到卸载出内存为止,它的整个生命周期包括: 加载-验证-准备-解析-初始化-使用-卸载。加载-验证-准备自然需要在初始化之前,解析有可能在初始化之后,这是为了支持Java语言的运行时绑定(也称为动态绑定或晚期绑定),其他阶段按顺序开始,而不是按顺序进行或完成,因为这些阶段通常都是互相交叉地混合进行的,通常在一个阶段执行的过程中调用或激活另一个阶段。
绑定:把一个方法的调用与方法所在的类(方法主体)关联起来,对java来说,绑定分为静态绑定和动态绑定:
- 静态绑定:即前期绑定。在程序执行前方法已经被绑定,此时由编译器或其它连接程序实现。可以理解为程序编译期的绑定。只有final,static,private和构造方法是前期绑定的。
- 动态绑定:即晚期绑定,也叫运行时绑定。在运行时根据具体对象的类型进行绑定,几乎所有的方法都是后期绑定的。
(1) 装载:查找和导入Class文件;
(2) 链接:把类的二进制数据合并到JRE中;
(a)校验:检查载入Class文件数据的正确性;
(b)准备:给类的静态变量分配存储空间;
(c)解析:将符号引用转成直接引用;
(3) 初始化:对类的静态变量,静态代码块执行初始化操作
加载:
将类的.class文件中的二进制数据读入到内存中,将其放在运行时数据区的方法区内,然后在堆区创建一个java.lang.Class对象,用来封装类在方法区内的数据结构。类的加载的最终产品是位于堆区中的Class对象,Class对象封装了类在方法区内的数据结构,并且向Java程序员提供了访问方法区内的数据结构的接口。
类加载器并不需要等到某个类被“首次主动使用”时再加载它,JVM规范允许类加载器在预料某个类将要被使用时就预先加载它,如果在预先加载的过程中遇到了.class文件缺失或存在错误,类加载器必须在程序首次主动使用该类时才报告错误(LinkageError错误)如果这个类一直没有被程序主动使用,那么类加载器就不会报告错误。
加载.class文件的方式有:
1. 从本地系统中直接加载
2. 通过网络下载.class文件
3. 从zip,jar等归档文件中加载.class文件
4. 从专有数据库中提取.class文件
5. 将Java源文件动态编译为.class文件
JVM的主要工作:
1)通过一个类的全限定名获取定义此类的二进制字节流。
2)将这个字节流所表示的静态存储结构转化为方法区运行时数据结构。
3)在内存中生成一个代表这个类的 class 对象,作为方法区的各种数据的访问入口。
类加载器虽然只用于实现类的加载动作,但它在Java程序中起到的作用却远远不限于类的加载阶段。对于任意一个类,都需要由它的类加载器和这个类本身一同确定其在就Java虚拟机中的唯一性,也就是说,即使两个类来源于同一个Class文件,只要加载它们的类加载器不同,那这两个类就必定不相等。
站在Java虚拟机的角度来讲,只存在两种不同的类加载器:
- 启动类加载器:它使用C++实现(这里仅限于Hotspot,也就是JDK1.5之后默认的虚拟机,有很多其他的虚拟机是用Java语言实现的),是虚拟机自身的一部分。
- 所有其他的类加载器:这些类加载器都由Java语言实现,独立于虚拟机之外,并且全部继承自抽象类java.lang.ClassLoader,这些类加载器需要由启动类加载器加载到内存中之后才能去加载其他的类。
站在Java开发人员的角度来看,类加载器可以大致划分为以下三类:
- 启动类加载器:Bootstrap ClassLoader,跟上面相同。它负责加载存放在JDK\jre\lib(JDK代表JDK的安装目录,下同)下,或被-Xbootclasspath参数指定的路径中的,并且能被虚拟机识别的类库(如rt.jar,所有的java.*开头的类均被Bootstrap ClassLoader加载)。启动类加载器是无法被Java程序直接引用的。
- 扩展类加载器:Extension ClassLoader,该加载器由sun.misc.Launcher$ExtClassLoader实现,它负责加载JDK\jre\lib\ext目录中,或者由java.ext.dirs系统变量指定的路径中的所有类库(如javax.*开头的类),开发者可以直接使用扩展类加载器。
- 应用程序类加载器:Application ClassLoader,该类加载器由sun.misc.Launcher$AppClassLoader来实现,它负责加载用户类路径(ClassPath)所指定的类,开发者可以直接使用该类加载器,如果应用程序中没有自定义过自己的类加载器,一般情况下这个就是程序中默认的类加载器。
应用程序都是由这三种类加载器互相配合进行加载的,如果有必要,我们还可以加入自定义的类加载器。这几种类加载器的层次关系如下图所示:
这种层次关系称为类加载器的双亲委派模型。我们把每一层上面的类加载器叫做当前层类加载器的父加载器,当然,它们之间的父子关系并不是通过继承关系来实现的,而是使用组合关系来复用父加载器中的代码。
双亲委派模型的工作流程是:如果一个类加载器收到了类加载的请求,它首先不会自己去尝试加载这个类,而是把请求委托给父加载器去完成,依次向上,因此,所有的类加载请求最终都应该被传递到顶层的启动类加载器中,只有当父加载器在它的搜索范围中没有找到所需的类时,即无法完成该加载,子加载器才会尝试自己去加载该类。
使用双亲委派模型来组织类加载器之间的关系,有一个很明显的好处,就是Java类随着它的类加载器(说白了,就是它所在的目录)一起具备了一种带有优先级的层次关系,这对于保证Java程序的稳定运作很重要。例如,类java.lang.Object类存放在JDK\jre\lib下的rt.jar之中,因此无论是哪个类加载器要加载此类,最终都会委派给启动类加载器进行加载,这边保证了Object类在程序中的各种类加载器中都是同一个类。
委派的好处就是避免有些类被重复加载。双亲委派的实现:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 protected synchronized Class<?> loadClass(String paramString, boolean paramBoolean) 2 throws ClassNotFoundException 3 { 4 //检查是否被加载过 5 Class localClass = findLoadedClass(paramString); 6 //如果没有加载,则调用父类加载器 7 if (localClass == null) { 8 try { 9 //父类加载器不为空 10 if (this.parent != null) 11 localClass = this.parent.loadClass(paramString, false); 12 else { 13 //父类加载器为空,则使用启动类加载器 14 localClass = findBootstrapClass0(paramString); 15 } 16 } 17 catch (ClassNotFoundException localClassNotFoundException) 18 { 19 //如果父类加载失败,则使用自己的findClass方法进行加载 20 localClass = findClass(paramString); 21 } 22 } 23 if (paramBoolean) { 24 resolveClass(localClass); 25 } 26 return localClass; 27 }
先检查是否已经被加载过,若没有加载则调用父类加载器的loadClass方法,若父类加载器不存在,则使用启动类加载器。如果父类加载器加载失败,则抛出异常之后看,再调用自己的findClass方法进行加载。
双亲委派模式优势
采用双亲委派模式的是好处是Java类随着它的类加载器一起具备了一种带有优先级的层次关系,通过这种层级关可以避免类的重复加载,当父亲已经加载了该类时,就没有必要子ClassLoader再加载一次。其次是考虑到安全因素,java核心api中定义类型不会被随意替换,假设通过网络传递一个名为java.lang.Integer
的类,通过双亲委托模式传递到启动类加载器,而启动类加载器在核心Java API发现这个名字的类,发现该类已被加载,并不会重新加载网络传递的过来的java.lang.Integer
,而直接返回已加载过的Integer.class,这样便可以防止核心API库被随意篡改。可能你会想,如果我们在classpath路径下自定义一个名为java.lang.SingleInterge
类(该类是胡编的)呢?该类并不存在java.lang
中,经过双亲委托模式,传递到启动类加载器中,由于父类加载器路径下并没有该类,所以不会加载,将反向委托给子类加载器加载,最终会通过系统类加载器加载该类。但是这样做是不允许,因为java.lang
是核心API包,需要访问权限,强制加载将会报出如下异常
java.lang.SecurityException: Prohibited package name: java.lang
所以无论如何都无法加载成功的。
验证:
验证的目的是为了确保 clsss 文件的字节流中包含的信息符合当前虚拟机的要求,且不会危害虚拟机自身的安全。验证阶段大致会完成下面 4 个阶段的检验动作:1)文件格式验证 2)元数据验证 3)字节码验证 4)符号引用验证{字节码验证将对类的方法进行校验分析,保证被校验的方法在运行时不会做出危害虚拟机的事,一个类方法体的字节码没有通过字节码验证,那一定有问题,但若一个方法通过了验证,也不能说明它一定安全}。
准备:
准备阶段是正式为类变量分配内存并设置变量的初始化值的阶段,这些变量所使用的内存都将在方法区中进行分配。(不是实例变量,且是初始值,若 public static int a=123;准备阶段后 a 的值为 0,而不是 123,要在初始化之后才变为 123,但若被 final 修饰,public static final int a=123;在准备阶段后就变为了 123)
1)这时候进行内存分配的仅包括类变量(static),而不包括实例变量,实例变量会在对象实例化时随着对象一块分配在Java堆中。
2)这里所设置的初始值通常情况下是数据类型默认的零值(如0、0L、null、false等),而不是被在Java代码中被显式地赋予的值。
解析:
虚拟机将常量池中的符号引用变为直接引用的过程。
符号引用(Symbolic Reference):符号引用以一组符号来描述所引用的目标,符号引用可以是任何形式的字面量,符号引用与虚拟机实现的内存布局无关,引用的目标并不一定已经在内存中。
直接引用(Direct Reference) :直接引用可以是直接指向目标的指针、相对偏移量或是一个能间接定位到目标的句柄。直接引用是与虚拟机实现的内存布局相关的,同一个符号引用在不同的虚拟机实例上翻译出来的直接引用一般都不相同,如果有了直接引用,那引用的目标必定已经在内存中存在。
1、类或接口的解析:判断所要转化成的直接引用是对数组类型,还是普通的对象类型的引用,从而进行不同的解析。
2、字段解析:对字段进行解析时,会先在本类中查找是否包含有简单名称和字段描述符都与目标相匹配的字段,如果有,则查找结束;如果没有,则会按照继承关系从上往下递归搜索该类所实现的各个接口和它们的父接口,还没有,则按照继承关系从上往下递归搜索其父类,直至查找结束。
3、类方法解析:对类方法的解析与对字段解析的搜索步骤差不多,只是多了判断该方法所处的是类还是接口的步骤,而且对类方法的匹配搜索,是先搜索父类,再搜索接口。
4、接口方法解析:与类方法解析步骤类似,只是接口不会有父类,因此,只递归向上搜索父接口就行了。
初始化:
类初始化阶段是类加载过程的最后一步,前面的类加载过程中,除了加载(Loading)阶段用户应用程序可以通过自定义类加载器参与之外,其余动作完全由虚拟机主导和控制。到了初始化阶段,才真正开始执行类中定义的Java程序代码。
初始化,为类的静态变量赋予正确的初始值,JVM负责对类进行初始化,主要对类变量进行初始化。在Java中对类变量进行初始值设定有两种方式:
①声明类变量时指定初始值
②使用静态代码块为类变量指定初始值
JVM初始化步骤
1、假如这个类还没有被加载和连接,则程序先加载并连接该类
2、假如该类的直接父类还没有被初始化,则先初始化其直接父类
3、假如类中有初始化语句,则系统依次执行这些初始化语句
初始化阶段时执行类构造器()方法的过程。
1)<clinit>()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块(static{}块)中的语句合并产生的,编译器收集的顺序由语句在源文件中出现的顺序所决定。
2)<clinit>()方法与类的构造函数不同,它不需要显式地调用父类构造器,虚拟机会保证在子类的<clinit>()方法执行之前,父类的<clinit>()方法已经执行完毕,因此在虚拟机中第一个执行的<clinit>()方法的类一定是java.lang.Object。
3)由于父类的<clinit>()方法先执行,也就意味着父类中定义的静态语句块要优先于子类的变量赋值操作。
4)<clinit>()方法对于类或者接口来说并不是必需的,如果一个类中没有静态语句块也没有对变量的赋值操作,那么编译器可以不为这个类生成<clinit>()方法。
5)接口中可能会有变量赋值操作,因此接口也会生成<clinit>()方法。但是接口与类不同,执行接口的<clinit>()方法不需要先执行父接口的<clinit>()方法。只有当父接口中定义的变量被使用时,父接口才会被初始化。另外,接口的实现类在初始化时也不会执行接口的<clinit>()方法。
6)虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确地加锁和同步。如果有多个线程去同时初始化一个类,那么只会有一个线程去执行这个类的<clinit>()方法,其它线程都需要阻塞等待,直到活动线程执行<clinit>()方法完毕。如果在一个类的<clinit>()方法中有耗时很长的操作,那么就可能造成多个进程阻塞。
类初始化的触发条件:只有当对类的主动使用的时候才会导致类的初始化。
(1)遇到new、getstatic、putstatic或invokestatic这4条字节码指令时,如果类没有进行过初始化,则需要先触发其初始化。生成这4条指令的最常见的Java代码场景是:使用new关键字实例化对象的时候,读取或设置一个类的静态字段(被final修饰、已在编译期把结果放入常量池的静态字段除外)的时候,以及调用一个类的静态方法的时候。
(2) 使用java.lang.reflect包的方法对类进行反射调用的时候,如果类没有进行过初始化,则需要先触发其初始化。
(3) 当初始化一个类的时候,如果发现其父类还没有进行过初始化,则需要先触发其父类的初始化。
(4) 当虚拟机启动时,用户需要指定一个要执行的主类(包含main()方法的那个类),虚拟机会先初始化这个主类。
只有上述四种情况会触发初始化,也称为对一个类进行主动引用,除此以外,所有其他方式都不会触发初始化,称为被动引用。
关于上面的这四种说法,换一种通俗的解释应该对应下面的六种:
(1) 创建类的实例,也就是new的方式
(2) 访问某个类或接口的静态变量,或者对该静态变量赋值
(3) 调用类的静态方法
(4) 反射(如Class.forName(“com.shengsiyuan.Test”))
(5) 初始化某个类的子类,则其父类也会被初始化
(6) Java虚拟机启动时被标明为启动类的类(Java Test),直接使用java.exe命令来运行某个主类
在遇到下列情况时,若没有初始化,则需要先触发其初始化():
JAVA的初始化顺序:
父类的静态成员初始化>父类的静态代码块>子类的静态成员初始化>子类的静态代码块>父类的代码块>父类的构造方法>子类的代码块>子类的构造方法
变量初始化的几种情况:
1.方法内的局部变量:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 void f() { 2 int i; 3 i++; 4 }
会编译出错,编译器不会默认赋初值。
2.类的属性变量(基本类型):
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 public class Test1 { 2 3 boolean bo; 4 char c; 5 byte by; 6 short sh; 7 int i; 8 long l; 9 float f; 10 double d; 11 String s; 12 13 public void print() { 14 System.out.println(bo + "," + c + "," + by + "," + sh); 15 System.out.println(i + "," + l + "," + f + "," + d); 16 } 17 public static void main(String[] args) { 18 Test1 test = new Test1(); 19 test.print(); 20 } 21 22 } 23 //运行结果:false, ,0,0,0,0,0.0,0.0,null
对于类的成员变量,编译器会默认给初值。也可以在定义的时候直接给初值。
3.类的非基本类型属性变量:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 class Depth {} 2 public class Measurement { 3 Depth d = new Depth(); 4 }
如果没有为d指定初始值就尝试使用它,会出现运行时错误。
4.构造器初始化:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 public class Counter { 2 int i; 3 public Counter() { 4 i = 7; 5 } 6 }
i会首先被置0,然后变成7。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 class Window {} 2 class House { 3 Window w1 = new Window(1); 4 House() { 5 print("house"); 6 w3 = new Window(33); 7 } 8 Window w2 = new Window(2); 9 Window w3 = new Window(3); 10 } 11 public class Main { 12 public static void main(String[] args) { 13 House h = new House(); 14 } 15 } 16 //初始化顺序:w1,w2,w3,house,w33
在类的内部,变量定义的先后顺序决定了初始化的顺序,即使变量定义散布于方法定义之间,它们仍旧会在任何方法(包括构造器)被调用之前得到初始化。
w3这个引用会被初始化两次:一次在调用构造器前,一次在调用期间(第一次引用的对象将被丢弃,并作为垃圾回收)。
对于父类和子类构造器的初始化:
子类构造器顺序:
1)隐式或显式的调用super来调用父类的构造器。
2)子类中的其余部分被初始化。
5.static数据:静态初始化只在class对象首次加载的时候进行一次。
6.数组:
数组定义:是相同类型的、用一个标识符名称封装到一起的一个对象序列。
对于a2=a1这种赋值,是赋的a1的引用,而不仅仅是a1的内容,所以对a2的修改,其实也是对a1的修改。
int[] a = new int[10];会默认初始化数组中的值为默认值(数字和字符,就是0;布尔型就是false)。
Integer[] a = new Integer[10];这只是个引用数组,直到通过创建新的Integer对象,并把对象赋值给引用,初始化进程才算结束,例如:a[0] = new Integer(1);如果忘记创建对象,并试图使用数组中的空引用,就会在运行时产生异常。
例子:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 public class DynamicArray { 2 public static void main(String[] args) { 3 Other.main(new String[]{"fiddle","de","dum"}); 4 } 5 } 6 class Other { 7 public static void main(String[] args) { 8 for(String s : args) { 9 print(s); 10 } 11 } 12 } 13 //结果:fiddle de dum