首页 > 编程语言 > 详细

Java的类加载

时间:2018-09-26 16:39:51      阅读:120      评论:0      收藏:0      [点我收藏+]

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

Java的类加载

原文:https://www.cnblogs.com/liangyueyuan/p/9703735.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!