Java的类加载
虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这就是Java虚拟机的类加载机制
----类加载的大致过程
类的加载的过程一共分为三个步骤：加载、链接和初始化
加载：是类加载的一个阶段，由类加载器执行，查找字节码，并创建一个Class对象（只是创建）。
这里就引出了另外一个概念，java的动态加载，即java程序在运行时并不一定被完整加载，只有当发现该类还没有加载时，才去本地或远程查找类的.class文件并验证和加载
并且当程序创建了第一个对类的静态成员的引用（如类的静态变量、静态方法、构造方法——构造方法也是静态的）时，才会加载该类
所以加载并不意味着这个字节码文件就要被初始化
链接：链接其实分为三个部分，验证、准备和解析。
验证：即验证二进制字节码文件在结构上的正确性，目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全
准备：准备阶段主要是创建静态域，分配空间，给这些域设默认值，为类变量分配内存并且设置类变量初始值，这些变量所使用的内存都将在方法区中进行分配
注意这里不会为实例变量分配空间，实例变量将会在对象实例化的时候一起进入java堆中。假如：
public static int value = 13；
那变量value在准备阶段的值就不是13而是0，因为这时候尚未开始执任何的java方法
解析：解析的过程就是对类中的接口、类、方法、变量的符号引用进行解析并定位，解析成直接引用（符号引用就是编码是用字符串表示某个变量、接口的位置，直接引用就是根据符号引用翻译出来的地址），并保证这些类被正确的找到
初始化：类加载的最后一步，真正开始执行类中定义的java程序代码
static{}是在第一次初始化时执行，且只执行一次
类的加载方式可以分为：类的主动引用和类的被动引用
类的主动引用（一定会发生类的初始化） --new一个类的对象 --调用类的静态成员（除了final常量）和静态方法 --使用java.lang.reflect包的方法对类进行反射调用（Class.forName(xxx.xxx.xxx)） --当初始化一个类，如果其父类没有被初始化，则先初始化他的父类 --当要执行某个程序时，一定先启动main方法所在的类 类的被动引用（不会发生类的初始化） --当访问一个静态变量时，只有真正声明这个静态变量的类才会被初始化（通过子类引用父类的静态变量，不会导致子类初始化） --通过数组定义类应用，不会触发此类的初始化 A[] a = new A[10]; --引用常量(final类型)不会触发此类的初始化（常量在编译阶段就存入调用类的常量池中了）
----例子1结合分析：
class Singleton{ private static Singleton singleton = new Singleton(); public static int value1; public static int value2 = 0; private Singleton(){ value1++; value2++; } public static Singleton getInstance(){ return singleton; } } class Singleton2{ public static int value1; public static int value2 = 0; private static Singleton2 singleton2 = new Singleton2(); private Singleton2(){ value1++; value2++; } public static Singleton2 getInstance2(){ return singleton2; } } public class Test7 { public static void main(String[] args) { Singleton singleton = Singleton.getInstance(); System.out.println("Singleton1 value1:" + singleton.value1); System.out.println("Singleton1 value2:" + singleton.value2); Singleton2 singleton2 = Singleton2.getInstance2(); System.out.println("Singleton2 value1:" + singleton2.value1); System.out.println("Singleton2 value2:" + singleton2.value2); } }
输出的结果：
Singleton1 value1:1 Singleton1 value2:0 Singleton2 value1:1 Singleton2 value2:1
过程：
1 首先执行main中的Singleton singleton = Singleton.getInstance();
2 类的加载：加载类Singleton 3 类的验证 4 类的准备：为静态变量分配内存，设置默认值。这里为singleton(引用类型)设置为null,value1,value2（基本数据类型）设置默认值0
5 类的初始化（按照赋值语句进行修改）： 执行private static Singleton singleton = new Singleton(); 执行Singleton的构造器：value1++;value2++; 此时value1，value2均等于1 执行 public static int value1; public static int value2 = 0; 此时value1=1，value2=0
6.Singleton2和Singleton的不同之处在于执行private static Singleton singleton = new Singleton(); 这句的时候在变量赋值之后，
所以，当虚拟机已经为value1和value2分配好内存后设置默认值之后（准备过程），又执行了
public static int value1; public static int value2 = 0;
此时value1，value2都是0；
接着因为实例化对象，调用了构造器方法，value1和value2都变成了1
两者的区别在于:调用构造器的顺序不同
----例子2结合分析
class B { static int value = 100; static { System.out.println("Class B is initialized"); } } class A extends B { static { System.out.println("Class A is initialized"); } } public class Test4 { public static void main(String[] args) { System.out.println(A.value); } }
输出结果：
Class B is initialized
100
过程：
当访问一个静态变量时，只有真正声明这个静态变量的类才会被初始化（通过子类引用父类的静态变量，不会导致子类初始化），
虽然这里的A来引用了value，但是value是在父类中静态声明的，所以子类A并不会初始化
----例子3结合分析
class StaticBlock { static final int c = 3; static final int d; static int e = 5; static { d = 5; e = 10; System.out.println("Initializing"); } StaticBlock() { System.out.println("Building"); } } public class Test4 { public static void main(String[] args) { System.out.println(StaticBlock.c); System.out.println(StaticBlock.d); System.out.println(StaticBlock.e); } }
输出结果：
3
Initializing
5
10
过程：
这里将要引出另外一个概念：编译时常量，即被static、final所修饰的常量，这种常量不需要初始化就可以被加载，就不会引起类的初始化。
所以，上边的程序中c就是一个编译时常量，不会引起类的初始化，直接加载输出，而d是个静态的变量，会引起类的加载，所以会先加载static块的内容，然后d就被赋值成5。
变量e呢，它有点类似上边例子1的情况，在准备阶段设置默认值为0后，然后又被赋值为5，接着类的加载需要执行static块的内容，所以e又被赋值成10
----类加载器
在java中，类的加载，离不开类加载器的配合，一般分为三个部分：启动类加载器、扩展类加载器和应用程序类加载器。当然，有时候我们还可以自定义类加载器，需要注意的是，Java虚拟机对class文件采用的是按需加载的方式，也就是说当需要使用该类时才会将它的class文件加载到内存生成class对象，而且加载某个类的class文件时，Java虚拟机采用的是双亲委派模式即把请求交由父类处理，是一种任务委派模式。
三大类加载器
1)启动类加载器,使用c++编写(BootStrap),负责加载rt.jar，没有父类 2)扩展类加载器,java实现(ExtClassLoader)，负责加载<JAVA_HOME>/lib/ext目录下的，父类加载器为null 3)应用程序加载器,java实现(AppClassLoader) ，也成为系统类加载器，负责加载ClassPath上所指定的类库，
如果应用程序没有自定义过自己的类加载器，一般情况下这个就是程序中默认的类加载器,父类加载器为ExtClassLoader
双亲委派工作原理：如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行，如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器，如果父类加载器可以完成类加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载。
双亲委派的优势：采用双亲委派模式的是好处是Java类随着它的类加载器一起具备了一种带有优先级的层次关系，通过这种层级关可以避免类的重复加载，当父亲已经加载了该类时，就没有必要子ClassLoader再加载一次。其次是考虑到安全因素，如果不使用这种委托方式，那么可以随时使用自定义的String来动态替Java核心的API中定义的类型，这样会存在非常大的安全隐患，而父类委托方式可以避免这种情况，因为String在启动的时候就已经被加载，所以，用户自定义类无法加载一个自定义的ClassLoader
一些重要方法：
----loaderClass方法
loadClass()方法是ClassLoader类自己实现的，该方法中的逻辑就是双亲委派模式的实现。源码如下：
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException { synchronized (getClassLoadingLock(name)) { // 先从缓存查找该class对象，找到就不用重新加载 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 // 如果都没有找到，则通过自定义实现的findClass去查找并加载 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; } }
----findClass(String)方法
目的是从本地文件系统使用实现的类装载器装载一个类。为了创建自己的类装载器，应该扩展ClassLoader类，这是个抽象类，可创建一个FileClassLoaderextends ClassLoader,然后覆盖ClassLoader类findClass(String name)方法，这个方法通过类的名字来得到一个对象
public Class findClass(String name){ byte[] data = loadClassData(name); return defineClass(name,data,0,data.length); }
----defineClass(byte[] b, int off, int len)方法
defineClass方法接受由原始字节组成的数组，并且把它转成Class对象。原始数组包含如从文件系统或者网络装入的数据，defineClass管理着JVM的许多复杂的实现层面——它把字节码分析成运行时的数据结构、检验有效性等，因为defineClass方法被标记为final，所以也不能覆盖它
----resolveClass(Class≺?≻ c)
使用该方法可以使用类的Class对象创建完成也同时被解析
？----怎么确定两个类是否相等
比较两个类是否相等，只有在这两个类是由同一个类加载器加载的前提下才有意义，否则，即使这两个类来源于同一Class文件，被同一个虚拟机加载，只要加载它们的类加载器不同，那么这两个类必定不相等
？----什么是热部署类加载器
所谓的热部署就是利用同一个class文件不同的类加载器在内存创建出两个不同的class对象，于JVM在加载类之前会检测请求的类是否已加载过(即在loadClass()方法中调用findLoadedClass()方法)，如果被加载过，则直接从缓存获取，不会重新加载。注意同一个类加载器的实例和同一个class文件只能被加载器一次，多次加载将报错，因此我们实现的热部署必须让同一个class文件可以根据不同的类加载器重复加载，以实现所谓的热部署。
?----破坏双亲委派模型-线程上下文加载器
简单来说，java应用中的很多服务都要依靠第三方的支持，如jdbc之类的，那么它们为java提供的接口是放在rt.jar包下，由BootStrap类加载器加载，然而它们这些接口的实现；类和方法却放在ClassPath下，这就很难受了，因为java程序当要使用第三方的接口服务时，那么这些接口是有启动类加载器加载，可是没办法加载具体的接口实现类，由于双亲委派模型存在，BootStrap类加载器又没办法反向去找AppClassLoader类加载器进行实现。
为了解决这个问题，便引入了线程上下文加载器，它默认是AppClassLoader类加载器，它将jdbc等SPI接口实现类进行加载，就是我们常见的ClassPath路径下的那些jar包之类的，然后BootStrap类加载器就可以去委托该加载器，将相关的实现类加载到内存中以便使用
本人菜鸟一枚，拜读了诸多大佬文章之后，以及查阅书籍，做了简单的小结记录，以便今后面试查阅使用
主要参考资料：https://blog.csdn.net/javazejian/article/details/73413292
https://www.cnblogs.com/zhguang/p/3154584.html#classLoader
《深入了解JAVA虚拟机》
