类的加载过程
loading 加载
通过双亲委派机制进行加载。主要出于安全的考虑。父加载器不是加载器的加载器，也不是父类加载的加载器。
- linking 链接
- verification 验证
- preparation 准备 静态变量赋默认值，private static int test =10; 在这个阶段只是 test赋默认值0，而不是10。
- resolution 解析 将类、方法、属性等符号引用解析为直接引用。常量池中的各种符号引用解析为指针，偏移量等内存地址的直接引用。
- initalizing 初始化 private static int test =10在这一步才会被赋值成test=10
类的加载过程
public class T002_ClassLoaderLevel {
public static void main(String[] args) {
// 由顶层类 Bootstrap加载
System.out.println(String.class.getClassLoader());
System.out.println(sun.net.spi.nameservice.dns.DNSNameService.class.getClassLoader());
System.out.println(T002_ClassLoaderLevel.class.getClassLoader());
System.out.println(sun.net.spi.nameservice.dns.DNSNameService.class.getClassLoader().getClass().getClassLoader());
System.out.println(T002_ClassLoaderLevel.class.getClassLoader().getClass().getClassLoader());
System.out.println(new T006_MSBClassLoader().getParent());
System.out.println(ClassLoader.getSystemClassLoader());
}
}
每个类被加载后都会产生一个对应的class对象，我们可以通过class对象去获取。输出结果为：
null
sun.misc.Launcher$ExtClassLoader@5e2de80c
sun.misc.Launcher$AppClassLoader@18b4aac2
null
null
sun.misc.Launcher$AppClassLoader@18b4aac2
sun.misc.Launcher$AppClassLoader@18b4aac2
我们先看了一下String的ClassLoad，String是属于核心类库，使用顶层类加载器Bootstrap加载，所以打印为null，sun.net.spi.nameservice.dns.DNSNameService的ClassLoad是ExtClassLoader，然后我们通过System.out.println(sun.net.spi.nameservice.dns.DNSNameService.class.getClassLoader().getClass().getClassLoader());获取DNSNameService的加载器的加载器也就是ExtClassLoader的在加载器打印也为null，也就是说ExtClassLoader的加载器是Bootrap。各种加载器的层级关系如下图
一个类被加载到内存中的过程是先按照左边的箭头方向以此判断是否已经被加载，如果到了Bootstrap发现没有被加载，则会按照有测箭头方向依次向下执行加载操作，假如我们有个自定义加载器的类第一次被加载，过程为：去查看CustomClassLoad是否已经加载=否>查看AppClassLoad=否>查看ExtensionClassLoad=否>查看Bootstrap=否>Bootstrap尝试加载，不是核心类库=>ExtensionClassLoad加载=没有找到>AppClassLoad加载=没有找到>CustomClassLoad加载成功加载或者抛出异常ClassNotFoundException，我们通常说 Bootstrap是所以加载器的父类，custom ClassLoad是底层加载器，是不是意味着上面的图就是按照Bootstrap=>Extension=>APP=>Custom ClassLoad的继承关系过来的呢？答案是否定的，上面的关系并不是按照继承的关系来的。他们是按照下图的方式继承的。比如CustomClassLoad的父加载器是AppClassLoad，是CustomClassLoad的成员变量中保存了AppClassLoad。
问：为什么要使用双亲委派机制？
主要是为了安全。假如所有的加载操作都使用一个类加载，我就可以自己自定义一个核心类库比如String去覆盖jdk提供的String，我们现在使用双亲委派机制，每次加载一个类都会先向查看是否已经被加载如果已经被加载直接返回。同时上层已经加载完成下层就不需要加载了。
下面通过一个小程序查看一下不同的加载器分别加载了哪些东西。
public class T003_ClassLoaderScope {
public static void main(String[] args) {
String pathBoot = System.getProperty("sun.boot.class.path");
System.out.println(pathBoot.replaceAll(";", System.lineSeparator()));
System.out.println("--------------------");
String pathExt = System.getProperty("java.ext.dirs");
System.out.println(pathExt.replaceAll(";", System.lineSeparator()));
System.out.println("--------------------");
String pathApp = System.getProperty("java.class.path");
System.out.println(pathApp.replaceAll(";", System.lineSeparator()));
}
}
输出结果为：
/Library/Java/JavaVirtualMachines/jdk1.8.0_231.jdk/Contents/Home/jre/lib/resources.jar
:/Library/Java/JavaVirtualMachines/jdk1.8.0_231.jdk/Contents/Home/jre/lib/rt.jar
:/Library/Java/JavaVirtualMachines/jdk1.8.0_231.jdk/Contents/Home/jre/lib/sunrsasign.jar
:/Library/Java/JavaVirtualMachines/jdk1.8.0_231.jdk/Contents/Home/jre/lib/jsse.jar
:/Library/Java/JavaVirtualMachines/jdk1.8.0_231.jdk/Contents/Home/jre/lib/jce.jar
:/Library/Java/JavaVirtualMachines/jdk1.8.0_231.jdk/Contents/Home/jre/lib/charsets.jar
:/Library/Java/JavaVirtualMachines/jdk1.8.0_231.jdk/Contents/Home/jre/lib/jfr.jar
:/Library/Java/JavaVirtualMachines/jdk1.8.0_231.jdk/Contents/Home/jre/classes
--------------------
/Users/yanghongxing/Library/Java/Extensions
:/Library/Java/JavaVirtualMachines/jdk1.8.0_231.jdk/Contents/Home/jre/lib/ext
:/Library/Java/Extensions:/Network/Library/Java/Extensions:/System/Library/Java/Extensions
:/usr/lib/java
--------------------
/Users/yanghongxing/Library/Application Support/Code/User/workspaceStorage/7172d33d4189eaa64607305e947a5428/redhat.java/jdt_ws/src_28ac311/bin
如何实现一个自定义类加载器
首先搞清楚一件事，如果我们要加载一个类怎么写？我们直接调用AppClassLoad的loadClass()方法即可
public class Test {
public static void main(String[] args) throws ClassNotFoundException {
//执行加载操作
Class clazz = Test.class.getClassLoader().loadClass("com.yhx.test.Test1");
System.out.println(clazz.getName());
}
}
下面我们看一下加载过程的源码：
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;
}
.....
protected Class findClass(String name) throws ClassNotFoundException {
throw new ClassNotFoundException(name);
}
}
先开始通过findLoadedClass(name)查看是否已经加载过，返回null则没有被加载，调用父类的findLoadedClass(name)查看方法返回，这一部分就相当于我们之前的双亲委派的加载示意图的左边的箭头，查看是否被加载，如果全部都是未加载，开始执行示意图的右半部分， long t1 = System.nanoTime(); c = findClass(name);调用findClass这个方法，但是这个方法就直接抛出异常。（所以我们再实现自定义加载器只要继承ClassLoader重写其中的findClass方法即可）抛出异常会被子类捕获，子类就会重复执行find操作。
public class Test extends ClassLoader {
public static int seed = 0B10110110;
@Override
protected Class findClass(String name) throws ClassNotFoundException {
File f = new File("/Users/yanghongxing/Downloads", name.replace('.', '/').concat(".testclass"));
try {
FileInputStream fis = new FileInputStream(f);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
int b = 0;
while ((b=fis.read()) !=0) {
baos.write(b ^ seed);
}
byte[] bytes = baos.toByteArray();
baos.close();
fis.close();
// 这个方法可以把二进制流转换成class对象
return defineClass(name, bytes, 0, bytes.length);
} catch (Exception e) {
e.printStackTrace();
}
return super.findClass(name); //throws ClassNotFoundException
}
}
编译器
- 解释器 - bytecode inpetreter将字节码解释为操作系统能识别的机器码。
即时编译器 JTT -Just In Time Compiler，建字节码编译成机器码。
Java默认使用混合模式，起始阶段使用解释执行，运行时采用热点代码检测，多次被调用的方法（方法计数器：检测执行频率）多次调用的循环（循环计数器：检测循环调用的频率）使用参数 -Xmixed 混合模式 -Xint 解释模式 -Xcopm 编译模式
面试题
下面的代码执行结果是怎么样的？
public class Test {
public static void main(String[] args) {
System.out.println(T.count);
}
}
class T {
public static T t = new T(); // null
public static int count = 2; //0
//private int m = 8;
private T() {
count ++;
}
}
结果为2. 我们分析一下类T的加载过程，类在在加载时，加载给1.加载，2.链接，2.1校验，2.2准备，给静态成员变量赋初始值T t =null，int count=0。2.3解析，将类、方法、属性等符号引用解析为直接引用，T t指向new T（）并执行t的构造方法，此时执行 count++，count=1。3初始化，count=2。输出2。
思考：下面的代码执行结果如何？
public class Test {
public static void main(String[] args) {
System.out.println(T.count);
}
}
class T {
public static int count = 2;
public static T t = new T();
//private int m = 8;
private T() {
count ++;
}
}