更多 Java 虚拟机方面的文章，请参见文集《Java 虚拟机》
一个类 Person 从代码到使用：
- 编译器负责将 Person.java 源文件编译为 Person.class 字节码文件
- 类加载器 Class Loader 负责将 Person.class 字节码 （表现形式为字节数组 byte[]）转换为 JVM 中的 Class<Person> 对象
- 随后 JVM 再利用 Class<Person> 对象 实例化为 Person 对象
1. 类的加载
1.1 类加载器 Class Loader
作用：
- 将 .class 文件中的字节码转换为 JVM 中的 Class 对象（不是 Class 的实例）
-
为 JVM 中相同名称的类创建隔离空间。使得同一名称不同版本的两个 Java 类可以在 JVM 中同时存在，例如 OSGI。
在 JVM 中判断两个类是否相同：类的二进制名称相同 并且 类加载器相同
类加载器 Class Loader 具有层次组织结构，即每个类加载器都有一个父类加载器，通过 getParent() 可以获得父类加载器。
类加载器 Class Loader 使用代理模式，每个类加载器即可以自己完成 Java 类的定义工作，也可以代理给其他的类加载器来完成。
- 初始类加载器：启动一个类的加载过程
-
定义类加载器：负责最终定义这个类。
例如在下面的代码中，A 的定义类加载器负责启动 B 的加载过程：
class A {
private B b;
}
1.2 类加载器 Class Loader 的加载策略
- 类加载器在尝试自己去加载某个类之前，会首先代理给父类加载器。当父类加载器在 class path 中找不到对应的 .class 字节码文件时，才会尝试自己加载。
一般的 Java 应用使用该策略。从ClassLoader的loadClass()方法中可以看出c = parent.loadClass(name, false);：
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
// First, check if the class has already been loaded
Class<?> c = findLoadedClass(name);
if (c == null) {
long t0 = System.nanoTime();
try {
if (parent != null) {
c = parent.loadClass(name, false);
} else {
c = findBootstrapClassOrNull(name);
}
} catch (ClassNotFoundException e) {
// ClassNotFoundException thrown if class not found
// from the non-null parent class loader
}
if (c == null) {
// If still not found, then invoke findClass in order
// to find the class.
long t1 = System.nanoTime();
c = findClass(name);
// this is the defining class loader; record the stats
sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
}
- 相反策略，类加载器首先尝试自己去加载某个类，当其在 class path 中找不到对应的 .class 字节码文件时，再代理给父类加载器。
该策略在 Java Web 容器中比较常见。Apache Tomcat 为每个 Application 提供一个独立的类加载器WebappClassLoader，使得 Application 自己的类的优先级高于 Web 容器提供的类，因此不同的 Application 可以使用不同版本的库。
1.3 JVM 自带的 Class Loader
- SystemClassLoader：C++编写，加载核心库
java.* - ExtClassLoader：Java编写，加载扩展库
javax.* - AppClassLoader：Java编写，加载程序所在目录
通过 Thread.currentThread().getContextClassLoader() 获得当前类加载器
public static void main(String[] args) {
ClassLoader cl = Thread.currentThread().getContextClassLoader();
System.out.println(cl.toString());
try {
Class c = cl.loadClass("jvm.Person");
System.out.println(c.getClassLoader());
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
输出：
sun.misc.Launcher
AppClassLoader@75b84c92
1.4 自定义类加载器 Class Loader
继承父类 ClassLoader， ClassLoader 中包含如下方法：
-
final Class<?> defineClass(String name, byte[] b, int off, int len)- 将字节码数组转换为 Class<?> 对象
- 该方法不能被 override
-
final Class<?> findLoadedClass(String name)- 查找已经加载过的 Class<?> 对象，即 Java 类
- 一个类加载器不会重复加载同一个类
- 该方法不能被 override
-
Class<?> findClass(String name)- 根据名称查找并加载 Java 类
- 该方法需要被 override
-
Class<?> loadClass(String name)- 根据名称加载 Java 类
- 该方法不能被 override
例如我们可以自定义一个类加载器负责从网络中获取字节码，并转化为 Class 对象。
class MyClassLoader extends ClassLoader {
protected Class<?> findClass(String name) throws ClassNotFoundException {
byte[] bytes = new byte[1024];
// 从 网络中根据 name 读取 字节数组
// 将字节码数组转换为 Class<?> 对象
return defineClass(name, bytes, 0, bytes.length);
}
}
1.5 显示加载 VS 隐式加载
-
显示加载：
- 通过
Class c = Class.forName("Student"); - 通过 ClassLoader 的
loadClass()方法，例如：
- 通过
ClassLoader cl = Thread.currentThread().getContextClassLoader();
Class c = cl.loadClass("Student");
- Class.forName() 与 ClassLoader.loadClass() 的区别
-
隐式加载：通过
new，例如Student s = new Student("")
2. 类的链接
类的链接：将 Java 类的二进制代码合并到 JVM 的运行状态之中的过程。
包括三个步骤：
- 验证：确保 Java 类的二进制表示在结构上是合理的
- 准备：创建静态域并赋值
- 解析：确保当前类引用的其他类被正确地找到，该过程可能会触发其他类被加载。
关于解析，不同的 JVM 有不同的解析策略，例如：
public class A {
public void main(String args[]) {
B b = null;
}
}
- 策略1：链接 A 的时候发现引用了 B，因此加载 B
- 策略2：链接 A 的时候发现引用了 B，但是 B 没有被使用，因此不加载 B。在真正使用 B 时才加载 B，例如
b = new B();
3. 类的初始化
类的初始化：当 Java 类第一次被真正使用的时候，JVM 会负责初始化该类。包括：
- 执行静态代码块
- 初始化静态域
注意：是类的初始化，不是对象的初始化。
例如：下面的代码不会初始化类 A，因为 A 没有真正被使用。
public static void main(String[] args) {
A a;
}
static class A {
static int i = 10;
static {
System.out.println("Init class A");
}
}
例如：下面的代码会初始化类 A，因为 A 真正被使用，输出 Init class A
public static void main(String[] args) {
int i = A.i;
}
static class A {
static int i = 10;
static {
System.out.println("Init class A");
}
}
