Java的类加载

Posted 2021-01-08 凉月缘

   虚拟机把描述类的数据从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虚拟机》