JVM 类加载

JVM 类加载

目录

虚拟机类加载过程

虚拟机完整的加载过程为：

加载--验证--准备--解析--初始化--使用--卸载

这里可以简化为3个主要过程：

加载--链接--初始化

加载

将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区中的运行时数据结构，并在堆中生成一个代表这个类的java.lang.Class 对象，作为方法区类数据的访问入口。

链接

链接又具体分为3步

  • 1.验证：确保加载的类信息符合JVM规范，没有安全性问题
  • 2.准备：正式为类变量（即static变量）分配内存并设置变量初始值的阶段，这些内存都将在方法区中进行分配，但注意只是初始分配变量，变量的值都是初始值
  • 3.解析：将虚拟机常量池（常量池中就包括类名，变量名，一些基本数据类型值）内的符号引用替换为直接引用，也就是让常量池中的值指向其对应的引用这样就能引用到常量池中的常量

在链接的完成之后，程序就具备了初始化的能力

初始化

  • 初始化阶段就是执行类构造器()方法的过程，注意不是对象构造器()，类构造器()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块中的语句合并产生的，也就是我们没有办法去直接定义但是其内容是由我们写的类变量的赋值动作和静态语句块定义的。

  • 当初始化一个类的时候，如果发现父类还没有进行初始化，则需要先触发其父类的初始化

  • 虚拟机会保证一个类的类构造器()方法在多线程环境中被正确加锁和同步，也就是类初始过程一定是线程安全的

  • 当访问一个Java类的静态域时，只有真正声明这个域的类才会被初始化（主动引用和被动引用）

类的主动引用和被动引用
  • 主动引用：--主动引用一定会发生类的初始化
  • new一个类对象
  • 调用类的静态成员（不包括final常量）和静态方法
  • 使用反射机制对类进行反射调用
    -调用类的main方法
    初始化子类，则其父类也一定被初始化或已经初始化
  • 类的被动引用（不会发生类的初始化）
  • 引用常量不会出发类的初始化，常量在编译阶段就会存入调用类的常量 池中。（
    常量池在java用于保存在编译期已确定的，已编译的class文件中的一份数据。它包括了关于类，方法，接口等中的常量，也包括字符串常量，如String s = "java"这种申明方式；当然也可扩充，执行器产生的常量也会放入常量池，故认为常量池是JVM的一块特殊的内存空间。）
  • 通过子类调用父类的静态变量，不会导致子类的初始化即只有真正声明这个域的类才会被初始化名字类访问父类并不使用子类则子类不会被初始化
  • 通过数组定义不会导致类初始化：即Class[] a=new Class[8]不会初始化类
使用

当初始化完成后，使用类时，则会在栈中加入main方法栈帧，如果main方法中继续调用其他方法则在main栈帧上继续压栈，同时如果新建对象则也会在堆中实例化对象并指向栈中方法的引用

图示：

类加载器

ClassLoader

public abstract class ClassLoader extends Object

类加载器是负责加载类的对象。 ClassLoader类是一个抽象类。 给定一个类的binary name ，类加载器应该尝试定位或生成构成类的定义的数据。 典型的策略是将名称转换为文件名，然后从文件系统中读取该名称的“类文件”。每个类对象包含reference来定义它的ClassLoader。类数组类的对象不是由类加载器创建的，而是按照Java运行时的要求自动创建的。 Class.getClassLoader()返回的数组类的类加载器与其元素类型的类加载器相同; 如果元素类型是原始类型，则数组类没有类加载器。应用程序实现ClassLoader的子类 ，以扩展Java虚拟机动态加载类的方式。

相关方法：
getParent() 返回该类加载器的父类加载器。
loadClass(String name) 加载名称为 name的类，返回的结果是 java.lang.Class类的实例。
findClass(String name) 查找名称为 name的类，返回的结果是 java.lang.Class类的实例。
findLoadedClass(String name) 查找名称为 name的已经被加载过的类，返回的结果是java.lang.Class类的实例。
defineClass(String name, byte[] b, int off, int len) 把字节数组 b中的内容转换成 Java 类，返回的结果是
java.lang.Class类的实例。这个方法被声明为 final的。
resolveClass(Class<?> c) 链接指定的 Java 类。

类加载器的作用

java.lang.ClassLoader类的基本职责：

  • 根据一个指定的类的名称， 找到或者生成其对应的字节代码，然后从这些字节代码中定义出一个 Java 类，即 java.lang.Class类的一个实例。
  • 除此之外，ClassLoader还负责加载 Java 应用所需的资源，如图像文 件和配置文件等。
  • 类缓存，标准的Java SE类加载器可以按要求查找类，但一旦某个类被加载到类加载 器中，它将维持加载（缓存）一段时间。不过，JVM垃圾收集器可以回收 这些Class对象

类加载器的层次结构（树结构）及双亲委托（代理）机制

类加载器的结构

引导类加载器（bootstrap class loader）

它用来加载 Java 的核心库(JAVA_HOME/jre/lib/rt.jar,或sun.boot.class.path路径下的 内容)，是用原生代码来实现的Native类，引导类加载器使用C++来写的，并不继承自 java.lang.ClassLoader。而扩展类加载器和应用程序类加载器或者自定义的类加载器都是继承自java.lang.ClassLoader，都是Java代码编写。

扩展类加载器（extensions class loader）

用来加载 Java 的扩展库(JAVA_HOME/jre/ext/*.jar，或java.ext.dirs路径下的内容) 。Java 虚拟机的实现会提供一个扩展库目录。该类加载器在此目录里面查找并加载 Java 类，由sun.misc.Launcher$ExtClassLoader实现

应用程序类加载器（application class loader）

它根据 Java 应用的类路径（classpath， java.class.path 路径下的内容）来加载 Java 类。 一般来说，Java 应用的类都是由它来完成加载的。由sun.misc.Launcher$AppClassLoader实现

自定义类加载器

开发人员可以通过继承 java.lang.ClassLoader类的方式 实现自己的类加载器，以满足一些特殊的需求

加载策略

类的加载策略就是代理模式即交给其他加载器来加载指定的类，具体的策略被称为双亲委托机制：
某个特定的类加载器在接到加载类的请求时，首先将加载任务委 托给父类加载器，依次追溯，直到最高的爷爷辈的，如果父类加载器 可以完成类加载任务，就成功返回；只有父类加载器无法完成此加载 任务时，才自己去加载。
双亲委托机制就了保证 Java 核心库的类型安全。 • 这种机制就保证不会出现用户自己能定义java.lang.Object类的情况。比如我们定义一个与JDK核心包中相同的类String结果就是编译器加载不到：

但并不是所有的类加载器都采用双亲委托机制，因为双亲委派首要考虑的是安全但明显灵活性不够。 –tomcat服务器类加载器也使用代理模式，所不同的是它是首先尝试去加载某个类，如果找不到再代理给父类加载器。 这与一般类加载器的顺序是相反的

自定义加载器

自定义加载器流程：

  • 0、继承：java.lang.ClassLoader
  • 1、首先检查请求的类型是否已经被这个类装载器装载到命名空间中了，如果已经装载，直接返回；否则转入步骤2
  • 2、委派类加载请求给父类加载器（更准确的说应该是双亲类加载器，真个虚拟机中各种类加载器最终会呈现树状结构），如果父类加 载器能够完成，则返回父类加载器加载的Class实例；否则转入步骤3
  • 3、调用本类加载器的findClass（…）方法，试图获取对应的字节码，如果获取的到，则调用defineClass（…）导入类型到方法区；如 果获取不到对应的字节码或者其他原因失败，返回异常给loadClass（…）， loadClass（…）转抛异常，终止加载过程（注意：这里的 异常种类不止一种）。
  • 注意：被两个类加载器加载的同一个类，JVM不认为是相同的类

示例：

package JavaCore.JVM.Loader_Basic;

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

/*******************************************************************************
 * @Copyright (C), 2018-2019,github:Swagger-Ranger 
 * @FileName: FileSystemClassLoader
 * @Author: liufei32@outlook.com
 * @Date: 2019/4/8 0:21
 * @Description: 自定义文件加载器
 * @Aha-eureka:  自定义加载类有几个关键方法：
 *                    findLoadedClass(String) 调用这个方法，查看这个Class是否已经别加载，如果没有被加载，继续往下走，查看父类加载器，
 *                递归调用loadClass()，如果父类加载器是null，说明是启动类加载器，查找对应的Class，如果都没有找到，就调用findClass(String)
 *                    findClass()：根据名称或位置加载.class字节码,然后使用defineClass
 *                    definclass()：把字节码转化为Class
 *
 *******************************************************************************/

public class FileSystemClassLoader extends ClassLoader{

    private String rootDir;

    public FileSystemClassLoader(String rootDir){
        this.rootDir = rootDir;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {

        Class<?> c = findLoadedClass(name);

        //应该要先查询有没有加载过这个类。如果已经加载，则直接返回加载好的类。如果没有，则加载新的类。
        if(c!=null){
            return c;
        }else{
            ClassLoader parent = this.getParent();
            try {
                c = parent.loadClass(name);	   //委派给父类加载
            } catch (Exception e) {
//				e.printStackTrace();
            }

            if(c!=null){
                return c;
            }else{
                byte[] classData = getClassData(name);
                if(classData==null){
                    throw new ClassNotFoundException();
                }else{
                    c = defineClass(name, classData, 0,classData.length);//defineClass就是将字节码转化为Class
                }
            }

        }

        return c;

    }

    private byte[] getClassData(String classname){   //com.bjsxt.test.User   d:/myjava/  com/bjsxt/test/User.class
        String path = rootDir +"/"+ classname.replace('.', '/')+".class";

//		IOUtils,可以使用它将流中的数据转成字节数组
        InputStream is = null;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try{
            is  = new FileInputStream(path);

            byte[] buffer = new byte[1024];
            int temp=0;
            while((temp=is.read(buffer))!=-1){
                baos.write(buffer, 0, temp);
            }

            return baos.toByteArray();
        }catch(Exception e){
            e.printStackTrace();
            return null;
        }finally{
            try {
                if(is!=null){
                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(baos!=null){
                    baos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

线程上下文加载器

双亲委派机制的问题：

  • 一般情况下, 保证同一个类中所关联的其他类都是由当前类的类加载器所加载的.。 比如，ClassA本身在Ext下找到，那么他里面new出来的一些类也就只能用Ext去查找了（不会低一个级别），所以有 些明明App可以找到的，却找不到了
  • API与SPI：SPI Service Provide Interface，接口的具体实现，比如JDBC的实现，一般由特定厂商提供。SPI 的接口API是 Java 核心库的一部分，是由引导类加载器来加载的;SPI 实现的 Java 类一般是由系统类加载器来加载的。引导类加载器是无法找到 SPI 的实现类的，因为它只加载 Java 的核心库。所有使用双亲委派也会导致无法加载

通常当你需要动态加载资源的时候 , 你至少有三个 ClassLoader 可以选择 :

  • 1.系统类加载器或叫作应用类加载器 (system classloader or application classloader)
  • 2.当前类加载器
  • 3.当前线程类加载器

当前线程类加载器是为了抛弃双亲委派加载链模式。 – 每个线程都有一个关联的上下文类加载器。如果你使用new Thread()方式生成新的线程，新线程将继承其父线程的上 下文类加载器。如果程序对线程上下文类加载器没有任何改动的话，程序中所有的线程将都使用系统类加载器作为上 下文类加载器。
使用：Thread.currentThread().getContextClassLoader()来获取到线程的加载器，和使用Thread.currentThread().setContextClassLoader()来设置线程的加载器

tomcat类加载机制

  • tomcat web容器在运行时提供了一个类似于沙箱的机制，容器限制类在指定的地方，否则就不会被加载。这样tomcat就不能使用系统默认的类加载器，如果TOMCAT跑你的WEB项目使用系统的类加载器那是相当危险的，你可 以直接是无忌惮是操作系统的各个目录了。
  • 同时每个 Web 应用都有一个对应的类加载器实例，因为Class只会被加载一次，而判断两个实例是否是同一个Class不仅要看是否源码相同同时也要看使用的类加载器是否相同，如果tomcat使用相同的类加载器实例，那两个实例之久就可以通过Class类即反射机制去访问另一个类，那就破坏了安全性。
  • tomcat类加载器也使用代理模 式(不同于前面说的双亲委托机制)，所不同的是它是首先尝试去加载某个 类，如果找不到再代理给父类加载器。这与一般类加载器的顺序是相反的 。但也是为了保证安全，这样核心库就不在查询范围之内。

OSGI原理

OSGi(Open Service Gateway Initiative)技术是Java动态化模块化系统的一系列规范。OSGi一方面指维护OSGi规范的OSGI官方联盟，另一方面指的是该组织维护的基于Java语言的服务（业务）规范。简单来说，OSGi可以认为是Java平台的模块层。
OSGi服务平台向Java提供服务，这些服务使Java成为软件集成和软件开发的首选环境。Java提供在多个平台支持产品的可移植性。OSGi技术提供允许应用程序使用精炼、可重用和可协作的组件构建的标准化原语，这些组件能够组装进一个应用和部署中。

OSGi 中的每个模块（bundle）都包含 Java 包和类。模块可以声明它所依赖的需要导入 （import）的其它模块的 Java 包和类（通过 Import-Package），也可以声明导出（ export）自己的包和类，供其它模块使用（通过 Export-Package）。也就是说需要能 够隐藏和共享一个模块中的某些 Java 包和类。这是通过 OSGi 特有的类加载器机制来 实现的。OSGi 中的每个模块都有对应的一个类加载器。它负责加载模块自己包含的 Java 包和类。当它需要加载 Java 核心库的类时（以 java开头的包和类），它会代理给 父类加载器（通常是启动类加载器）来完成。当它需要加载所导入的 Java 类时，它会 代理给导出此 Java 类的模块来完成加载。模块也可以显式的声明某些 Java 包和类，必 须由父类加载器来加载。只需要设置系统属性 org.osgi.framework.bootdelegation 的值即可。

posted on 2019-04-08 12:54  Swagger-Ranger  阅读(148)  评论(0)  编辑  收藏  举报

导航