【面试重点】Java类加载机制和类加载器
Java类加载机制概述
虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验，解析和初始化，最终形成可以被虚拟机直接使用的Java类型。
HotspotVM默认使用懒加载机制，在加载开始后，连接紧接着执行(并不是加载完成后，连接才执行，两者可以理解为并行执行)，加载完毕后，连接才会完毕。
初始化【面试重点】
- 1、遇到new，getstatic、putstatic或者invokestatic这4条字节码指令时，如果类没有进行过初始化，则需要先触发其初始化。生成这4条指令的最常见的Java代码场景是：使用new关键字实例化对象的时候、读取或设置一个类的静态字段（被final修饰、已经在编译期把结果放入常量池的静态字段除外）的时候，以及调用一个类的静态方法的时候。
- 2、使用过Java.lang.reflect包的方法对类进行反射调用的时候，如果类没有进行过初始化，则需要先触发其初始化。
- 3、当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
- 4、当虚拟机启动时，用户需要指定一个要执行的主类(包含main()方法的那个类)，虚拟机会先初始化这个主类。
不被初始化的例子
- 通过子类引用父类的静态字段 (父类会被初始化，子类不会被初始化)
- 通过数组定义引用类
- 调用类的常量
验证手段:模拟一个父类和子类，使用静态代码块判断静态代码块是否执行来判断类是否被初始化
验证1: 通过子类引用父类的静态字段 (父类会被初始化，子类不会被初始化)
//子类
package cn.itcats.jvm.load;
public class Child extends Parent{
static {
System.out.println("Child has been loaded...");
}
}
//父类
package cn.itcats.jvm.load;
public class Parent {
public static int num= 10;
static {
System.out.println("parent class has been loaded...");
}
}
//测试类1
package cn.itcats.jvm.load;
public class LoadTest1 {
public static void main(String[] args) {
//通过子类引用父类的静态字段 (父类会被初始化，子类不会被初始化)
System.out.println(Child.num);
}
}运行结果
parent class has been loaded...
10
//由此可见，通过子类引用父类的静态字段 (父类会被初始化，子类不会被初始化)
验证2: 通过数组定义引用类
//子类
package cn.itcats.jvm.load;
public class Child extends Parent{
static {
System.out.println("Child has been loaded...");
}
}
//父类
package cn.itcats.jvm.load;
public class Parent {
static {
System.out.println("parent class has been loaded...");
}
}package cn.itcats.jvm.load;
public class LoadTest1 {
public static void main(String[] args) {
//通过数组定义引用类
Child[] childArray = new Child[10];
}
}
运行结果 : 无结果
通过数组定义引用类，父类和子类都不会被加载
验证3：调用类的常量
package cn.itcats.jvm.load;
public class Child extends Parent{
//类的常量
public static final int value = 10;
static {
System.out.println("Child has been loaded...");
}
}
package cn.itcats.jvm.load;
public class Parent {
public static int num= 10;
static {
System.out.println("parent class has been loaded...");
}
}
package cn.itcats.jvm.load;
public class LoadTest1 {
public static void main(String[] args) {
//引用类的静态常量
System.out.println(Child.value);
}
}
运行结果 : 10 //可见静态代码块都未执行，调用类的常量时子类父类都未被初始化
类加载的过程
加载:
作为类加载过程的第一阶段，它是：
- 通过一个类的全限定名来获取定义此类的二进制流
加载源有很多包括：编译后生成的class文件、jar文件，网络获取(Applet)，计算生成的二进制流ProxyGenerator，jsp，数据库等
- 将这个字节流所代表的静态存储结构转化为方法区运行时的数据存储结构
- 在内存中生成一个代表这个类的class对象，作为这个类的各种数据访问入口 (注意:HotspotVM会把class对象放在方法区中，而不是堆中)
验证: (连接的第一个阶段) 可以设置跳过验证
- 这一阶段的目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全
- 文件格式验证
CAFE BABE 副主版本号是否是当前虚拟机所能认识执行的，若版本号大于虚拟机所能支持的版本号，则无法执行，检查常量池中是否含有不被支持的常量类型(tag)，指向常量的索引中是否含有不存在的常量或不支持的常量等......- 元数据验证
对字节码描述的信息进行语义的分析，如:任何的类都有父类，若无父类则不正确；被final修饰的类是否被继承?......- 字节码验证
分析控制流(顺序、选择、循环)分析语义是否合法- 符号引用验证
确保解析的动作能够正常执行。符号引用中通过字符串描述全限定名是否能够找到对应的类，如常量池中某一常量指向一个类，则确保指向的这个类是否存在，在指定类是否有方法描述或字段描述(No suchMethod或No suchFiled异常)
准备: (连接的第二个阶段)
- 准备阶段正式为类变量(static修饰变量或被final修饰的常量，在此过程中常量被初始化为指定的值)分配内存并设置变量的初始化值(初始化为默认值)，这些变量使用的内存都将在方法区中进行分配。 public static int a = 5; //这里得初始值并不是5，而是其默认值int默认值0。
解析 : (连接过程的最后一个阶段)
解析阶段是虚拟机将常量池中的符号引用替换为直接引用的过程
- 类或接口的解析
- 字段解析
- 类方法解析
- 接口方法解析
初始化
类初始化阶段是类加载过程的最后一步，前面类加载的过程中除了在加载阶段用户应用程序可以通过自定义类加载器参与以外，其余动作完全由虚拟机主导与控制。到了初始化阶段，才是真正执行类中定义的Java程序代码。
在准备阶段，变量已经赋过一次系统要求的初始值，而在初始化阶段，则根据开发者通过程序控制指定的主观计划去初始化类变量和其他资源。
初始化阶段是执行类构造器
()方法的过程
关于
先来看一段代码
上面这段代码变量的赋值语句可以通过编译，而下面的输出却编译不通过。这是为什么呢？
再来看一段代码
package cn.itcats.jvm.init;
public class Parent {
public static int a = 1;
static {
a = 2;
}
public static void main(String[] args) {
/*根据类初始化条件,此处读取了Child类的静态变量b(常量不行),Child对象会被初始化
* 而Child存在父类Parent，则Parent先初始化完毕
*/
System.out.println(Child.b);
}
}
class Child extends Parent{
public static int b =a;
}
运行结果: 2
子类的
接口中也有变量要赋值，也会生成
如果多个线程同时初始化一个类，只有一个线程会执行这个类的
package cn.itcats.jvm.init;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class InitThread {
static class Hello {
static {
System.out.println(Thread.currentThread().getName() + "init...");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
ExecutorService threadPool = Executors.newFixedThreadPool(5);
int i =0 ;
while(i++ <= 5) {
threadPool.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"start...");
Hello hello = new Hello();
System.out.println(Thread.currentThread().getName()+"end...");
}
});
}
}
}
执行结果 :
pool-1-thread-2start...
pool-1-thread-5start...
pool-1-thread-1start...
pool-1-thread-4start...
pool-1-thread-3start...
pool-1-thread-5init...
事实发现
类加载器
虚拟机的设计团队把类加载阶段中的"通过一个类的全限定名来获取描述此类的二进制字节流"这个动作放到Java虚拟机外部去实现，以便让应用程序自己决定如果去获取所需要的类。实现这个动作的代码模块称之为类加载器。
只有被同一个类加载器加载的类才可能会相等。相同的字节码被不同的类加载器加载的类不相等。
加载器的分类
- 启动类加载器 ，由C++ 实现，没有父类，用于加载javahome下的lib目录下的包；
- 扩展类加载器，由Java语言实现，父类加载器为null，加载javahome下 /lib/ext 目录中的类；
- 系统类加载器，由Java语言实现，父类加载器为扩展类加载器；
- 自定义类加载器，父类加载器肯定为AppClassLoader。
如何自定义类加载器?
- 定义一个类，继承ClassLoader类
- 重写loadClass()方法
- 实例化Class对象
具体代码实现：
package cn.itcats.jvm.classloader;
import java.io.IOException;
import java.io.InputStream;
/**
* 自定义一个类加载器
* @author fatah
*/
public class ClassLoaderTest extends ClassLoader{
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
ClassLoader classLoader = new ClassLoader() {
//重写loadClass方法
public Class loadClass(String name) throws ClassNotFoundException {
//cn.itcats.jvm.classloader
String filename = name.substring(name.lastIndexOf(".")+1) + ".class";
InputStream input = getClass().getResourceAsStream(filename);
if(input==null) {
return super.loadClass(name);
}
try {
byte [] buff = new byte[input.available()];
input.read(buff);
return defineClass(name, buff, 0, buff.length);
} catch (IOException e) {
throw new ClassNotFoundException();
}
}
};
Object obj = classLoader.loadClass("cn.itcats.jvm.classloader.ClassLoaderTest").newInstance();
System.out.println(obj.getClass()); //class cn.itcats.jvm.classloader.ClassLoaderTest
//比较自定义类加载器和程序应用加载器对比
System.out.println(obj instanceof ClassLoaderTest); //false
}
}
自定义类加载器的优势有什么?
- 类加载器是Java语言的一项创新，也是Java语言流行的重要原因之一，它最初的设计是为了满足Java Applet的需求二开发出来的
- 高度的灵活性
- 通过自定义类加载器可以实现热部署
- 实现代码加密
类加载的顺序
普通类：
* 静态变量
* 静态代码块
* 普通变量
* 普通代码块
* 构造函数
继承的子类：
* 父类静态变量
* 父类静态代码块
* 子类静态变量
* 子类静态代码块
* 父类普通变量
* 父类普通代码块
* 父类构造函数
* 子类普通变量
* 子类普通代码块
* 子类构造函数
抽象的实现子类: 接口 - 抽线类 - 实现类
* 接口静态变量
* 抽象类静态变量
* 抽象类静态代码块
* 实现类静态变量
* 实现类静态代码块
* 抽象类普通变量
* 抽象类普通代码块
* 抽象类构造函数
* 实现类普通变量
* 实现类普通代码块
* 实现类构造函数
这么多的类加载器是如何协同工作的呢?
可以查看我的另外一篇博文《双亲委派模型》