类的加载过程
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对象去获取。输入后果为：
nullsun.misc.Launcher$ExtClassLoader@5e2de80csun.misc.Launcher$AppClassLoader@18b4aac2nullnullsun.misc.Launcher$AppClassLoader@18b4aac2sun.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 ++; }}