精华内容
下载资源
问答
  • Java类加载机制

    万次阅读 多人点赞 2019-03-02 10:21:04
    Java类加载机制 类加载的时机 隐式加载 new 创建类的实例, 显式加载:loaderClass,forName等 访问类的静态变量,或者为静态变量赋值 调用类的静态方法 使用反射方式创建某个类或者接口对象的Class对象。 初始化某个...

    Java类加载机制

    类加载的时机

    • 隐式加载 new 创建类的实例,
    • 显式加载:loaderClass,forName等
    • 访问类的静态变量,或者为静态变量赋值
    • 调用类的静态方法
    • 使用反射方式创建某个类或者接口对象的Class对象。
    • 初始化某个类的子类
    • 直接使用java.exe命令来运行某个主类

    类加载的过程

    我们编写的java文件都是保存着业务逻辑代码。java编译器将 .java 文件编译成扩展名为 .class 的文件。.class 文件中保存着java转换后,虚拟机将要执行的指令。当需要某个类的时候,java虚拟机会加载 .class 文件,并创建对应的class对象,将class文件加载到虚拟机的内存,这个过程被称为类的加载。

    在这里插入图片描述

    加载

    类加载过程的一个阶段,ClassLoader通过一个类的完全限定名查找此类字节码文件,并利用字节码文件创建一个class对象。

    验证

    目的在于确保class文件的字节流中包含信息符合当前虚拟机要求,不会危害虚拟机自身的安全,主要包括四种验证:文件格式的验证,元数据的验证,字节码验证,符号引用验证。

    准备

    为类变量(static修饰的字段变量)分配内存并且设置该类变量的初始值,(如static int i = 5 这里只是将 i 赋值为0,在初始化的阶段再把 i 赋值为5),这里不包含final修饰的static ,因为final在编译的时候就已经分配了。这里不会为实例变量分配初始化,类变量会分配在方法区中,实例变量会随着对象分配到Java堆中。

    解析

    这里主要的任务是把常量池中的符号引用替换成直接引用

    初始化

    这里是类记载的最后阶段,如果该类具有父类就进行对父类进行初始化,执行其静态初始化器(静态代码块)和静态初始化成员变量。(前面已经对static 初始化了默认值,这里我们对它进行赋值,成员变量也将被初始化)

    类记载器的任务是根据类的全限定名来读取此类的二进制字节流到 JVM 中,然后转换成一个与目标类对象的java.lang.Class 对象的实例,在java 虚拟机提供三种类加载器,引导类加载器,扩展类加载器,系统类加载器。

    forName和loaderClass区别

    • Class.forName()得到的class是已经初始化完成的。
    • Classloader.loaderClass得到的class是还没有链接(验证,准备,解析三个过程被称为链接)的。

    双亲委派

    双亲委派模式要求除了顶层的启动类加载器之外,其余的类加载器都应该有自己的父类加载器,但是在双亲委派模式中父子关系采取的并不是继承的关系,而是采用组合关系来复用父类加载器的相关代码。

    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 { // ExtClassLoader没有继承BootStrapClassLoader
                        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();
                    // AppClassLoader去我们项目中查找是否有这个文件,如有加载进来
                    // 没有就到用户自定义ClassLoader中加载。如果没有就抛出异常
                    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;
        }
    }
    

    工作原理

    如果一个类收到了类加载的请求,它并不会自己先去加载,而是把这个请求委托给父类加载器去执行,如果父类加载器还存在父类加载器,则进一步向上委托,依次递归,请求最后到达顶层的启动类加载器,如果弗雷能够完成类的加载任务,就会成功返回,倘若父类加载器无法完成任务,子类加载器才会尝试自己去加载,这就是双亲委派模式。就是每个儿子都很懒,遇到类加载的活都给它爸爸干,直到爸爸说我也做不来的时候,儿子才会想办法自己去加载。

    优势

    采用双亲委派模式的好处就是Java类随着它的类加载器一起具备一种带有优先级的层次关系,通过这种层级关系可以避免类的重复加载,当父亲已经加载了该类的时候,就没有必要子类加载器(ClassLoader)再加载一次。其次是考虑到安全因素,Java核心API中定义类型不会被随意替换,假设通过网路传递一个名为java.lang.Integer的类,通过双亲委派的的模式传递到启动类加载器,而启动类加载器在核心Java API发现这个名字类,发现该类已经被加载,并不会重新加载网络传递过来的java.lang.Integer.而之际返回已经加载过的Integer.class,这样便可以防止核心API库被随意篡改。可能你会想,如果我们在calsspath路径下自定义一个名为java.lang.SingInteger?该类并不存在java.lang中,经过双亲委托模式,传递到启动类加载器中,由于父类加载器路径下并没有该类,所以不会加载,将反向委托给子类加载器,最终会通过系统类加载器加载该类,但是这样做是不允许的,因为java.lang是核心的API包,需要访问权限,强制加载将会报出如下异常。

    java.lang.SecurityException:Prohibited package name: java.lang
    

    类与类加载器

    • 在JVM中标识两个Class对象,是否是同一个对象存在的两个必要条件
    • 类的完整类名必须一致,包括包名。
    • 加载这个ClassLoader(指ClassLoader实例对象)必须相同。

    双亲委派模式的破坏者:线程上下文类加载器

    在这里插入图片描述
    在Java应用中存在着很多服务提供者接口(Service Provider Interface,SPI),这些接口允许第三方为它们提供实现,如常见的 SPI 有 JDBC、JNDI等,这些 SPI 的接口属于 Java 核心库,一般存在rt.jar包中,由Bootstrap类加载器加载,而 SPI 的第三方实现代码则是作为Java应用所依赖的 jar 包被存放在classpath路径下,由于SPI接口中的代码经常需要加载具体的第三方实现类并调用其相关方法,但SPI的核心接口类是由引导类加载器来加载的,而Bootstrap类加载器无法直接加载SPI的实现类,同时由于双亲委派模式的存在,Bootstrap类加载器也无法反向委托AppClassLoader加载器SPI的实现类。在这种情况下,我们就需要一种特殊的类加载器来加载第三方的类库,而线程上下文类加载器就是很好的选择。

    线程上下文类加载器(contextClassLoader)是从 JDK 1.2 开始引入的,我们可以通过java.lang.Thread类中的getContextClassLoader()和 setContextClassLoader(ClassLoader cl)方法来获取和设置线程的上下文类加载器。如果没有手动设置上下文类加载器,线程将继承其父线程的上下文类加载器,初始线程的上下文类加载器是系统类加载器(AppClassLoader),在线程中运行的代码可以通过此类加载器来加载类和资源,如下图所示,以jdbc.jar加载为例

    对象的创建过程

    当虚拟机遇到一个new的指令的时候,首先去检查这个指令是否能在常量池中定位到一个类的符号引用,并检查这个符号引用代表的类是否已经被加载,解析和初始化过。如果没有则执行相应初始化的过程。在类加载检查通过后,接下来虚拟机将为新生对象分配内存,对象所需要的内存的大小在类加载完成后便可以完成确定内存分配完成以后,虚拟机需要将分配的内存空间都初始化为零值,保证了对象的实例字段在Java代码中可以不赋予初值就直接使用,程序能访问到这些字段的数据类型对应的零值。再接下来对象需要进行必要的设置,这个对象是哪个类的实例,如何才能找到这个类的元数据信息,如何找到对象的哈希码,对象的GC分带年龄。

    • Java堆如果是规整的采取:指针碰撞,
    • Java堆如果不是规整的话:空闲列表,在内存中直接分配一个足够大的内存空间划分给对象。
    • 对象创建是非常平凡的,在多线程的程序中会产生线程安全的问题,所以解决这个问题有两种方式
    • 使用CSA配上失败重试的方式来保证原子性
    • 内存分配动作按照线程划分在不同的空间之中进行,即每个线程在java堆中预先分配一个小块的内存成为本地分配缓冲,TLAB,哪个线程需要分配内存就在哪个线程的TALB上分配,只有在TALB用完之后才会重新分配新的TALB的时候才会同步锁定。

    对象的内存布局

    对象的内存布局一般分为三个部分:对象头,示例数据,对齐填充

    对象头中存放着对象自身的运行时数据,如哈希码,GC分带年龄,锁状态标志,偏向线程ID,线程持有的锁。

    对象头另外一部分还有类型指针,对象指向它类元数据的指针,虚拟机通过这个指针来确定这个对象是哪个类的实例。如果对象是一个java数组,那在对象头中还必须用一块用于记录数组长度的数据。因为虚拟机可以通过普通java对象的元数据信息确定java对象的大小。

    对象的访问定位方式

    句柄和直接指针

    • 如果使用句柄的话,要在java堆中开辟一个句柄池,用来存放句柄地址,句柄地址中包含对象实例数据(堆)和类型数据(方法区)各自的地址信息。
    • 是用句柄的好处就是引用中存储的是稳定的句柄地址,当被移动时只会修改句柄中的实例数据指针,而引用地址不会被改变。
    • 使用直接指针访问方式的最大好处就是速度更快,它节省了一次访问指针定位的时间开销,引用直接指向存放实例数据的堆内存,在该内存中存放着指向方法区的类型数据地址。
    展开全文
  • java类加载机制

    2018-10-31 13:40:11
    java 类加载机制,课程笔记。
  • JAVA类加载机制

    2020-11-12 16:03:33
    JAVA类加载机制java类加载机制类加载器主要分为以下四类类加载器产生过程三种类加载器的关系双亲委派机制loadClass()方法findClass()方法如何自定义类加载器? java类加载机制 什么是类加载机制? 我们编写的java文件...

    java类加载机制

    什么是类加载机制?

    我们编写的java文件是如何加载到JVM运行的
    	java文件----->javac命令----->class文件----java命令----
    当调用java命令执行class文件就会加载类,也就是如下三个过程
    类加载主要分为如下三个过程
    加载过程     在硬盘上查找并通过IO流读入字节码进JVM内存结构的方法区同时在堆上形成class对象
    连接过程  
        验证 校验字节码文件的正确性
        准备 为类的静态变量分配内存初始化为默认值,对于final static变量编译就分配了
        解析 将类中的符号引用转换为直接引用
    初始化过程 对类的静态变量初始化为指定的值 执行静态代码块
    

    类加载器主要分为以下四类

    不同的加载器加载不同的class文件
    	引导类加载器  负责加载jre/lib目录下的核心类库  类似rt.jar等jar包
    	扩展类加载器  负责加载jre/lib/ext目录中的IAR类包 
    	应用类加载器  负责加载ClassPath路径下的class字节码文件 主要就是自己写的类
    	自定义加载器  负责加载用户自定义路径下的class字节码文件 (路径自己定义)
    

    类加载器

    产生过程

    	本篇文章针对windows系统的类加载过程
    		第一步java会调用底层C++代码创建JVM虚拟机
    		创建一个引导类加载器实例C++实现
    		调用C创建JVM启动器实例sun.misc.Launcher类
    			该类初始化的时候会创建两种类加载器
    				扩展类加载器 
    				应用类加载器
    		源码如下
    		//构造器
    		public Launcher() {
            Launcher.ExtClassLoader var1;
            try {
            	//创建 扩展类加载器 
                var1 = Launcher.ExtClassLoader.getExtClassLoader();
            } catch (IOException var10) {
                ...
            }
            try {
            	//创建 应用类加载器 将扩展类加载器传入作为应用类加载器的parent属性
                this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
            } catch (IOException var9) {
                ...
            }
            获取运行类自己的加载器,默认是AppClassLoader加载器
            ClassLoader c = Launcher.getClassLoader()
            c.loadClass("...xxx.class")加载类
            加载完成后执行main方法入口
            运行
            JVM销毁   
    

    三种类加载器的关系

    	应用类加载器的父加载器是扩展类加载器
        扩展类加载器的父加载器是引导类加载器
    

    双亲委派机制

    	双亲委派机制是类加载过程中实现的一种加载方法 
    	当第一次加载类的时候
    		应用类加载器加载类不会直接去classPath路径下找class文件,而是会交给自己的父加载器(parent)
    		向上委托给扩展类加载器,而扩展类加载器仍然不会直接去ext路径下查找class文件,而是会交给
    		引导类加载器(C++实现),此时引导类加载器会去jre/lib目录下查找class文件,找不到返回null
    		找到直接加载,如果返回null则此时交给扩展类加载器处理,它会去ext路径下查找class文件,同理
    		找到加载,找不到返回null交给应用类加载器去classPath路径下加载,有则加载,没有则报错。
    	为什么要采用这种类加载方法?
    		沙箱安全机制保证jdk核心代码加载完毕 
    		可以避免类重复加载 
    	为什么不直接从引导类加载器向下加载?
        	大部分业务类是由应用类加载器加载 第一次加载慢 之后加载会很快 
    

    loadClass()方法

    功能:加载类

    	类加载过程中 ClassLoader的loadClass()是非常重要的
    	如下源码演示 c代表 因为引导类加载器是C++实现的 所以扩展类加载器的parent为空
    	Class<?> c = findLoadedClass(name);//如果是应用类,第一次c为null 第二次就直接返回
        if (c == null) {
            //判断parent是否为空 应用类加载器的parent就是扩展类加载器,在初始化Launcher的时候指定的
            if (parent != null) {
                //有父加载器就调用
                //应用类加载器---->扩展类加载器 
                c = parent.loadClass(name, false);
            }else {
                //扩展类加载器 ---> 引导类加载器
                c = findBootstrapClassOrNull(name);
            }
            //没有找到则向下调用findClass方法  扩展类加载器->应用类加载器
            if (c == null) {
                c = findClass(name);
            }
        }
        if (resolve) {
           resolveClass(c);
        }
        return c;
    
    

    findClass()方法

    功能:获取class对象

    	该方法由URLClassLoader类实现 关键代码如下
    		name就是类路径例如("com.nicky.classloader.TestClass")
    		res为字节数组
    		return defineClass(name, res);
    		返回class对象 Class<?>类型交给loadclass方法
    

    如何自定义类加载器?

    	根据源码ClassLoader里的例子演示
    	如果不想破坏双亲委派机制 直接重写findclass方法自定义类加载路径即可
    	如果想破坏双亲委派机制,就需要重写loadClass方法将关键代码修改
    

    NickyClassLoader.java 自定义类加载器
    破坏了双亲委派机制 重写loadclass方法
    因为双亲委派机制会在第二次加载同类名的时候直接加载
    例如Tomcat部署多个war包的情况下,2个不同的war包会有相同的类名
    双亲委派机制则会导致第二个加载的war包不能加载到自己war包的内容
    所以如果是java的包仍然采用双亲委派机制,自定义的包就必须得破坏双亲委派机制

    
    package com.nicky.classloader;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.lang.reflect.Method;
    
    
    /**
     * 自定义类加载器
     */
    public class NickyClassLoader {
    
        static class MyClassLoader extends ClassLoader {
    
            //破坏双亲委派机制
            @Override
            public Class<?> loadClass( String name ) 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();
                        //java自己的类 传递给上层加载器加载
                        if (!name.startsWith("com.nicky")){
                            c = super.getParent().loadClass(name);
                        }else{
                            c = findClass(name);
                        }
                    }
                    return c;
                }
            }
    
            private String classpath;
    
            public MyClassLoader( String classpath ) {
                this.classpath = classpath;
            }
    
            //可以自定义classloader加载class文件
            @Override
            protected Class<?> findClass( String name ) throws ClassNotFoundException {
                try {
                    byte[] data = getByte(name);
                    //将一个字节数组转为class对象 这个字节数组是class文件读取后最终的字节数组
                    return defineClass(name, data, 0, data.length);
                } catch (Exception e) {
                    e.printStackTrace();
                    throw new ClassNotFoundException();
                }
            }
    
            private byte[] getByte( String name ) throws IOException {
                name = name.replace(".", "/");
                FileInputStream fileInputStream = new FileInputStream(classpath + "/" + name + ".class");
                int len = fileInputStream.available();
                byte[] bytes = new byte[len];
                fileInputStream.read(bytes);
                fileInputStream.close();
                return bytes;
            }
        }
    
        //tomcat 如何实现 多个项目自定义类加载 
        public static void main( String[] args ) throws Exception {
        
            MyClassLoader classLoader = new MyClassLoader("E:/test");
            Class<?> aClass = classLoader.loadClass("com.nicky.classloader.TestClass");
            Object o = aClass.newInstance();
            Method say = aClass.getDeclaredMethod("say");
            say.invoke(o);
    
            MyClassLoader classLoader1 = new MyClassLoader("E:/test1");
            Class<?> aClass1 = classLoader1.loadClass("com.nicky.classloader.TestClass");
            Object o1 = aClass1.newInstance();
            Method say1 = aClass1.getMethod("say");
            say1.invoke(o1);
        }
    }
    
    

    两个不同的TestClass.class文件
    一个路径在
    E:\test\com\nicky\classloader\TestClass.class
    另一个在
    E:\test1\com\nicky\classloader\TestClass.class
    两个文件是两次编译形成

     public void say(){
            System.out.println("1111111");
        }
    
         public void say(){
            System.out.println("2222222");
        }
    

    最后打印效果如下
    在这里插入图片描述

    根据个人结合源码以及他人视频总结,如有错误望指正修改,谢谢大家。

    展开全文
  • jvm之java类加载机制和类加载器(ClassLoader)的详解

    万次阅读 多人点赞 2018-08-13 15:05:46
    当程序主动使用某个类时,如果该类还未被加载到内存中,则...如果没有意外,JVM将会连续完成3个步骤,所以有时也把这个3个步骤统称为类加载或类初始化。 一、类加载过程 1.加载 加载指的是将类的class文件...

    手把手写代码:三小时急速入门springboot—企业级微博项目实战--->csdn学院

          当程序主动使用某个类时,如果该类还未被加载到内存中,则JVM会通过加载、连接、初始化3个步骤来对该类进行初始化。如果没有意外,JVM将会连续完成3个步骤,所以有时也把这个3个步骤统称为类加载或类初始化。

                                                        

    一、类加载过程

    1.加载    

        加载指的是将类的class文件读入到内存,并为之创建一个java.lang.Class对象,也就是说,当程序中使用任何类时,系统都会为之建立一个java.lang.Class对象。

        类的加载由类加载器完成,类加载器通常由JVM提供,这些类加载器也是前面所有程序运行的基础,JVM提供的这些类加载器通常被称为系统类加载器。除此之外,开发者可以通过继承ClassLoader基类来创建自己的类加载器。

        通过使用不同的类加载器,可以从不同来源加载类的二进制数据,通常有如下几种来源。

    • 从本地文件系统加载class文件,这是前面绝大部分示例程序的类加载方式。
    • 从JAR包加载class文件,这种方式也是很常见的,前面介绍JDBC编程时用到的数据库驱动类就放在JAR文件中,JVM可以从JAR文件中直接加载该class文件。
    • 通过网络加载class文件。
    • 把一个Java源文件动态编译,并执行加载。

        类加载器通常无须等到“首次使用”该类时才加载该类,Java虚拟机规范允许系统预先加载某些类。

    2.链接

        当类被加载之后,系统为之生成一个对应的Class对象,接着将会进入连接阶段,连接阶段负责把类的二进制数据合并到JRE中。类连接又可分为如下3个阶段。

        1)验证:验证阶段用于检验被加载的类是否有正确的内部结构,并和其他类协调一致。Java是相对C++语言是安全的语言,例如它有C++不具有的数组越界的检查。这本身就是对自身安全的一种保护。验证阶段是Java非常重要的一个阶段,它会直接的保证应用是否会被恶意入侵的一道重要的防线,越是严谨的验证机制越安全。验证的目的在于确保Class文件的字节流中包含信息符合当前虚拟机要求,不会危害虚拟机自身安全。其主要包括四种验证,文件格式验证,元数据验证,字节码验证,符号引用验证。

        四种验证做进一步说明:

        文件格式验证:主要验证字节流是否符合Class文件格式规范,并且能被当前的虚拟机加载处理。例如:主,次版本号是否在当前虚拟机处理的范围之内。常量池中是否有不被支持的常量类型。指向常量的中的索引值是否存在不存在的常量或不符合类型的常量。

        元数据验证:对字节码描述的信息进行语义的分析,分析是否符合java的语言语法的规范。

        字节码验证:最重要的验证环节,分析数据流和控制,确定语义是合法的,符合逻辑的。主要的针对元数据验证后对方法体的验证。保证类方法在运行时不会有危害出现。

        符号引用验证:主要是针对符号引用转换为直接引用的时候,是会延伸到第三解析阶段,主要去确定访问类型等涉及到引用的情况,主要是要保证引用一定会被访问到,不会出现类等无法访问的问题。

       2)准备:类准备阶段负责为类的静态变量分配内存,并设置默认初始值。

       3)解析:将类的二进制数据中的符号引用替换成直接引用。说明一下:符号引用:符号引用是以一组符号来描述所引用的目标,符号可以是任何的字面形式的字面量,只要不会出现冲突能够定位到就行。布局和内存无关。直接引用:是指向目标的指针,偏移量或者能够直接定位的句柄。该引用是和内存中的布局有关的,并且一定加载进来的。

    3.初始化

        初始化是为类的静态变量赋予正确的初始值,准备阶段和初始化阶段看似有点矛盾,其实是不矛盾的,如果类中有语句:private static int a = 10,它的执行过程是这样的,首先字节码文件被加载到内存后,先进行链接的验证这一步骤,验证通过后准备阶段,给a分配内存,因为变量a是static的,所以此时a等于int类型的默认初始值0,即a=0,然后到解析(后面在说),到初始化这一步骤时,才把a的真正的值10赋给a,此时a=10。

    二、类加载时机

    1. 创建类的实例,也就是new一个对象
    2. 访问某个类或接口的静态变量,或者对该静态变量赋值
    3. 调用类的静态方法
    4. 反射(Class.forName("com.lyj.load"))
    5. 初始化一个类的子类(会首先初始化子类的父类)
    6. JVM启动时标明的启动类,即文件名和类名相同的那个类    

         除此之外,下面几种情形需要特别指出:

         对于一个final类型的静态变量,如果该变量的值在编译时就可以确定下来,那么这个变量相当于“宏变量”。Java编译器会在编译时直接把这个变量出现的地方替换成它的值,因此即使程序使用该静态变量,也不会导致该类的初始化。反之,如果final类型的静态Field的值不能在编译时确定下来,则必须等到运行时才可以确定该变量的值,如果通过该类来访问它的静态变量,则会导致该类被初始化。

    三、类加载器

        类加载器负责加载所有的类,其为所有被载入内存中的类生成一个java.lang.Class实例对象。一旦一个类被加载如JVM中,同一个类就不会被再次载入了。正如一个对象有一个唯一的标识一样,一个载入JVM的类也有一个唯一的标识。在Java中,一个类用其全限定类名(包括包名和类名)作为标识;但在JVM中,一个类用其全限定类名和其类加载器作为其唯一标识。例如,如果在pg的包中有一个名为Person的类,被类加载器ClassLoader的实例kl负责加载,则该Person类对应的Class对象在JVM中表示为(Person.pg.kl)。这意味着两个类加载器加载的同名类:(Person.pg.kl)和(Person.pg.kl2)是不同的、它们所加载的类也是完全不同、互不兼容的。

       JVM预定义有三种类加载器,当一个 JVM启动的时候,Java开始使用如下三种类加载器:

     1)根类加载器(bootstrap class loader):它用来加载 Java 的核心类,是用原生代码来实现的,并不继承自 java.lang.ClassLoader(负责加载$JAVA_HOME中jre/lib/rt.jar里所有的class,由C++实现,不是ClassLoader子类)。由于引导类加载器涉及到虚拟机本地实现细节,开发者无法直接获取到启动类加载器的引用,所以不允许直接通过引用进行操作。

    下面程序可以获得根类加载器所加载的核心类库,并会看到本机安装的Java环境变量指定的jdk中提供的核心jar包路径:

    public class ClassLoaderTest {
    
    	public static void main(String[] args) {
    		
    		URL[] urls = sun.misc.Launcher.getBootstrapClassPath().getURLs();
    		for(URL url : urls){
    			System.out.println(url.toExternalForm());
    		}
    	}
    }

    运行结果:

      2)扩展类加载器(extensions class loader):它负责加载JRE的扩展目录,lib/ext或者由java.ext.dirs系统属性指定的目录中的JAR包的类。由Java语言实现,父类加载器为null。

      3)系统类加载器(system class loader):被称为系统(也称为应用)类加载器,它负责在JVM启动时加载来自Java命令的-classpath选项、java.class.path系统属性,或者CLASSPATH换将变量所指定的JAR包和类路径。程序可以通过ClassLoader的静态方法getSystemClassLoader()来获取系统类加载器。如果没有特别指定,则用户自定义的类加载器都以此类加载器作为父加载器。由Java语言实现,父类加载器为ExtClassLoader。

    类加载器加载Class大致要经过如下8个步骤:

    1. 检测此Class是否载入过,即在缓冲区中是否有此Class,如果有直接进入第8步,否则进入第2步。
    2. 如果没有父类加载器,则要么Parent是根类加载器,要么本身就是根类加载器,则跳到第4步,如果父类加载器存在,则进入第3步。
    3. 请求使用父类加载器去载入目标类,如果载入成功则跳至第8步,否则接着执行第5步。
    4. 请求使用根类加载器去载入目标类,如果载入成功则跳至第8步,否则跳至第7步。
    5. 当前类加载器尝试寻找Class文件,如果找到则执行第6步,如果找不到则执行第7步。
    6. 从文件中载入Class,成功后跳至第8步。
    7. 抛出ClassNotFountException异常。
    8. 返回对应的java.lang.Class对象。

    四、类加载机制:

    1.JVM的类加载机制主要有如下3种。

    • 全盘负责:所谓全盘负责,就是当一个类加载器负责加载某个Class时,该Class所依赖和引用其他Class也将由该类加载器负责载入,除非显示使用另外一个类加载器来载入。
    • 双亲委派:所谓的双亲委派,则是先让父类加载器试图加载该Class,只有在父类加载器无法加载该类时才尝试从自己的类路径中加载该类。通俗的讲,就是某个特定的类加载器在接到加载类的请求时,首先将加载任务委托给父加载器,依次递归,如果父加载器可以完成类加载任务,就成功返回;只有父加载器无法完成此加载任务时,才自己去加载。
    • 缓存机制。缓存机制将会保证所有加载过的Class都会被缓存,当程序中需要使用某个Class时,类加载器先从缓存区中搜寻该Class,只有当缓存区中不存在该Class对象时,系统才会读取该类对应的二进制数据,并将其转换成Class对象,存入缓冲区中。这就是为很么修改了Class后,必须重新启动JVM,程序所做的修改才会生效的原因。

    2.这里说明一下双亲委派机制:

           双亲委派机制,其工作原理的是,如果一个类加载器收到了类加载请求,它并不会自己先去加载,而是把这个请求委托给父类的加载器去执行,如果父类加载器还存在其父类加载器,则进一步向上委托,依次递归,请求最终将到达顶层的启动类加载器,如果父类加载器可以完成类加载任务,就成功返回,倘若父类加载器无法完成此加载任务,子加载器才会尝试自己去加载,这就是双亲委派模式,即每个儿子都很懒,每次有活就丢给父亲去干,直到父亲说这件事我也干不了时,儿子自己才想办法去完成。

          双亲委派机制的优势:采用双亲委派模式的是好处是Java类随着它的类加载器一起具备了一种带有优先级的层次关系,通过这种层级关可以避免类的重复加载,当父亲已经加载了该类时,就没有必要子ClassLoader再加载一次。其次是考虑到安全因素,java核心api中定义类型不会被随意替换,假设通过网络传递一个名为java.lang.Integer的类,通过双亲委托模式传递到启动类加载器,而启动类加载器在核心Java API发现这个名字的类,发现该类已被加载,并不会重新加载网络传递的过来的java.lang.Integer,而直接返回已加载过的Integer.class,这样便可以防止核心API库被随意篡改。

    展开全文
  • 深入研究Java类加载机制 深入研究Java类加载机制 深入研究Java类加载机制 深入研究Java类加载机制
  • java 类加载机制

    2017-05-01 15:51:36
    背景   类加载可以将一个用全限定名来描述的类加载到虚拟机中,了解类加载机制可以帮助更快的解决一些日常的jar包冲突等问题。双亲委派模型  在java中,这些类加载器都由java语言实现,并且都继承自java.lang....

    背景

       类加载可以将一个用全限定名来描述的类加载到虚拟机中,了解类加载机制可以帮助更快的解决一些日常的jar包冲突等问题。

    双亲委派模型

      在java中,这些类加载器都由java语言实现,并且都继承自java.lang.ClassLoader。
      
      绝大部分java程序都会使用到下面三种类加载器:

    1. 启动类加载器:加载\lib目录下的jar包
    2. 扩展类加载器用来加载\lib\ext目录下jar
    3. 应用程序类加载器:负责加载用户类加载器路径上所指定的类库。

    下图展示了三个类加载器的关系:

    这里写代码片

    Java采用的是双亲委派模型,即当需要加载一个类的时候,优先由父类加载器加载。这样可以保障的是如果用户自己定义了一个基础类的class,系统则会优先加载系统自带的class,一定程度上保障了安全性。
    
    那么除了双亲委派模型,难道没有别的模型,这种模型有什么局限性呢?其实对于java而言,如果A类中引用了B,那么默认会使用A类的加载器去加载B,那么带来一个问题即,如果A是系统类,由启动类加载器加载,而B则是我们应用程序类,那么这个时候双亲委派模型就无法满足我们的要求,因为启动类加载器无法正常加载自定义类。类似的例子如jdbc,DriverManager是系统类加载器加载的,但是它可能引用到的是我们mysql jdbc。这个时候就用到了一个类ContextClassLoader。
    

    ContextClassLoader

    如上文所述,系统的类加载器无法加载应用程序的类,我们可以通过当前线程的上下文加载器,将我们的应用程序加载器或者自定义类加载器设置成上下文加载器,当需要加载用户自定义类的时候,从上下文中获取类加载器即可获取。
    
    一个非常典型的例子就是tomcat的类加载机制。一个tomcat可能会包含很多应用,需要解决两个问题:
    
    1. tomcat自己的类,如果每个应用都复制一份的话,成本太高,因此tomcat自带类需要共享。
    2. 每个应用自带的类需要隔离,例如两个应用依赖的是spring版本不同,那么如果共享的话,会导致类冲突。

        下图是tomcat的类加载器:
      这里写图片描述

      CommonClassLoader、CatalinaClassLoader、SharedClassLoader和WebappClassLoader分别加载/common/*、

    /server/、/shared/和/WebApp/WEB-INF/*的类,而CommonClassLoader的父加载器是java里面应用程序类加载器,在tomcat中CatalinaClassLoader、SharedClassLoader默认是和CommonClassLoader一个实例,CommonClassLoader加载三个系统目录下的类,而对于WebAppClassLoader,通过自定义类加载,并将其设置成线程上下文类加载器,从而实现类隔离。

    总结:

      本文描述了java的类加载器机制,java类加载器机制主要是以双亲委派为主,在特定的场景下由于类隔离等原因,会破坏掉双亲委派,实现更大的灵活性。

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,022
精华内容 6,808
关键字:

java类加载机制

java 订阅