当前位置：
  1. 首页
  2. 市民
  3. 正文

1. 类加载阶段

1.1 加载阶段

  • 将类的字节码载入方法区中，内部采用 c++ 的 instanceklass 描述 java 类，它的重要 field 有：
    • _java_mirror 即 java 的类镜像，例如对 string 来说，就是 string.class，作用是把 klass 暴 露给 java 使用
    • _super 即父类
    • _fields 即成员变量
    • _methods 即方法
    • _constants 即常量池
    • _class_loader 即类加载器
    • _vtable 虚方法表
    • _itable 接口方法表
  • 如果这个类还有父类没有加载，则先触发父类的加载。
  • 加载和链接可能是交替运行的。

注意：

  • instanceklass 这样的【元数据】是存储在方法区（1.8 后的元空间内），但 _java_mirror 是存储在堆中
  • 可以通过前面介绍的 hsdb 工具查看

1.2 链接阶段

验证

验证类是否符合 jvm规范，安全性检查，阻止不合法的类继续运行。用 ue 等支持二进制的编辑器修改 helloworld.class的魔数，在控制台运行：

e:\git\jvm\out\production\jvm>java cn.itcast.jvm.t5.helloworld
error: a jni error has occurred, please check your installation and try again
exception in thread "main" java.lang.classformaterror: incompatible magic value
3405691578 in class file cn/itcast/jvm/t5/helloworld
        at java.lang.classloader.defineclass1(native method)
        at java.lang.classloader.defineclass(classloader.java:763)
        at
java.security.secureclassloader.defineclass(secureclassloader.java:142)
        at java.net.urlclassloader.defineclass(urlclassloader.java:467)
        at java.net.urlclassloader.access$100(urlclassloader.java:73)
        at java.net.urlclassloader$1.run(urlclassloader.java:368)
        at java.net.urlclassloader$1.run(urlclassloader.java:362)
        at java.security.accesscontroller.doprivileged(native method)
        at java.net.urlclassloader.findclass(urlclassloader.java:361)
        at java.lang.classloader.loadclass(classloader.java:424)
        at sun.misc.launcher$appclassloader.loadclass(launcher.java:331)
        at java.lang.classloader.loadclass(classloader.java:357)
        at sun.launcher.launcherhelper.checkandloadmain(launcherhelper.java:495)

准备

为 static 变量分配空间，设置默认值：

  • static 变量在 jdk 7 之前存储于 instanceklass 末尾，从 jdk 7 开始，存储于 _java_mirror 末尾
  • static 变量分配空间和赋值是两个步骤，分配空间在准备阶段完成，赋值在初始化阶段完成
  • 如果 static 变量是 final 的基本类型，以及字符串常量，那么编译阶段值就确定了，赋值在准备阶 段完成
  • 如果 static 变量是 final 的，但属于引用类型，那么赋值也会在初始化阶段完成
  • 将常量池中的符号引用解析为直接引用

解析

将常量池中的符号引用解析为直接引用：

/**
* 解析的含义
*/
public class load2 {
    public static void main(string[] args) throws classnotfoundexception,ioexception {
        classloader classloader = load2.class.getclassloader();
        // loadclass 方法不会导致类的解析和初始化
        class<?> c = classloader.loadclass("cn.itcast.jvm.t3.load.c");
        // new c();
        system.in.read();
    }
}
class c {
	d d = new d();
}
class d {
}

1.3 初始化阶段

< init()> v 方法

初始化即调用 < cinit>()v ，虚拟机会保证这个类的『构造方法』的线程安全。

发生的时机

概括得说，类初始化是【懒惰的】

  • main 方法所在的类，总会被首先初始化
  • 首次访问这个类的静态变量或静态方法时
  • 子类初始化，如果父类还没初始化，会引发
  • 子类访问父类的静态变量，只会触发父类的初始化
  • class.forname
  • new 会导致初始化

不会导致类初始化的情况：

  • 访问类的 static final 静态常量（基本类型和字符串）不会触发初始化
  • 类对象.class 不会触发初始化
  • 创建该类的数组不会触发初始化
  • 类加载器的 loadclass 方法

测试代码：

class a {
    static int a = 0;
    static {
    	system.out.println("a init");
    }
}
class b extends a {
    final static double b = 5.0;
    static boolean c = false;
    static {
    	system.out.println("b init");
    }
}

验证（测试时请先全部注释，每次只执行其中一个）

public class load3 {
    // main方法的所在类总会被先初始化
    static {
    	system.out.println("main init");
    }
    public static void main(string[] args) throws classnotfoundexception {
        // 1. 静态常量（基本类型和字符串）不会触发初始化
        system.out.println(b.b);
        // 2. 类对象.class 不会触发初始化
        system.out.println(b.class);
        // 3. 创建该类的数组不会触发初始化
        system.out.println(new b[0]);
        // 4. 不会初始化类 b，但会加载 b、a
        classloader cl = thread.currentthread().getcontextclassloader();
        cl.loadclass("cn.itcast.jvm.t3.b");
        // 5. 不会初始化类 b，但会加载 b、a
        classloader c2 = thread.currentthread().getcontextclassloader();
        class.forname("cn.itcast.jvm.t3.b", false, c2);
        // 1. 首次访问这个类的静态变量或静态方法时
        system.out.println(a.a);
        // 2. 子类初始化，如果父类还没初始化，会引发
        system.out.println(b.c);
        // 3. 子类访问父类静态变量，只触发父类初始化
        system.out.println(b.a);
        // 4. 会初始化类 b，并先初始化类 a
        class.forname("cn.itcast.jvm.t3.b");
    }
}

1.4 练习

从字节码分析，使用 a，b，c 这三个常量是否会导致 e 初始化：

public class load4 {
    public static void main(string[] args) {
        system.out.println(e.a);
        system.out.println(e.b);
        system.out.println(e.c);
    }
}
class e {
    public static final int a = 10;
    public static final string b = "hello";
    public static final integer c = 20;
}

典型应用 – 完成懒惰初始化单例模式：

public final class singleton {
    private singleton() { }
    // 内部类中保存单例
    private static class lazyholder {
        static final singleton instance = new singleton();
    }
    // 第一次调用 getinstance 方法，才会导致内部类加载和初始化其静态成员
    public static singleton getinstance() {
    	return lazyholder.instance;
    }
}

以上的实现特点是：

  • 懒惰实例化
  • 初始化时的线程安全是有保障的

2. 类加载器

以 jdk 8 为例：

名称 加载哪的类 说明
bootstrap classloader(启动类加载器) java_home/jre/lib 无法直接访问
extension classloader(扩展类加载器) java_home/jre/lib/ext 上级为 bootstrap，显示为 null
application classloader(应用程序类加载器) classpath 上级为 extension
自定义类加载器 自定义 上级为 application

类加载器的优先级（由高到低）：启动类加载器 -> 扩展类加载器 -> 应用程序类加载器 -> 自定义类加载器

2.1 启动类加载器

用 bootstrap 类加载器加载类：

package cn.itcast.jvm.t3.load;
public class f {
    static {
   		system.out.println("bootstrap f init");
    }
}

执行：

package cn.itcast.jvm.t3.load;
public class load5_1 {
    public static void main(string[] args) throws classnotfoundexception {
        class<?> aclass = class.forname("cn.itcast.jvm.t3.load.f");
        // aclass.getclassloader()：获得aclass对应的类加载器
        system.out.println(aclass.getclassloader());
    }
}

输出：

  • -xbootclasspath 表示设置 bootclasspath
  • 其中 /a:. 表示将当前目录追加至 bootclasspath 之后
  • 可以有以下几个方式替换启动类路径下的核心类：
    • java -xbootclasspath: < new bootclasspath>
    • 前追加：java -xbootclasspath/a:<追加路径>
    • 后追加：java -xbootclasspath/p:<追加路径>

2.2 扩展类加载器

package cn.itcast.jvm.t3.load;
public class g {
    static {
    	system.out.println("classpath g init");
    }
}

程序执行：

public class load5_2 {
    public static void main(string[] args) throws classnotfoundexception {
        class<?> aclass = class.forname("cn.itcast.jvm.t3.load.g");
        system.out.println(aclass.getclassloader());
    }
}

输出结果：

classpath g init
sun.misc.launcher$appclassloader@18b4aac2 // 这个类是由应用程序加载器加载

写一个同名的类：

package cn.itcast.jvm.t3.load;
public class g {
    static {
    	system.out.println("ext g init");
    }
}

打个 jar 包：

e:\git\jvm\out\production\jvm>jar -cvf my.jar cn/itcast/jvm/t3/load/g.class // 将g.class打jar包
已添加清单
正在添加: cn/itcast/jvm/t3/load/g.class(输入 = 481) (输出 = 322)(压缩了 33%)

将 jar 包拷贝到java_home/jre/lib/ext（扩展类加载器加载的类必须是以jar包方式存在），重新执行 load5_2

输出：

ext g init
sun.misc.launcher$extclassloader@29453f44 // 这个类是由扩展类加载器加载

2.3 双亲委派模式

所谓的双亲委派，就是指调用类加载器的 loadclass 方法时，查找类的规则。

注意：这里的双亲，翻译为上级似乎更为合适，因为它们并没有继承关系

protected class<?> loadclass(string name, boolean resolve) throws classnotfoundexception {
    synchronized (getclassloadinglock(name)) {
        // 1. 检查该类是否已经加载
        class<?> c = findloadedclass(name);
        if (c == null) {
            long t0 = system.nanotime();
            try {
                if (parent != null) {
                    // 2. 有上级的话，委派上级 loadclass
                    c = parent.loadclass(name, false);
                } else {
                    // 3. 如果没有上级了（extclassloader），则委派
                    bootstrapclassloader
                    c = findbootstrapclassornull(name);
                }
            } catch (classnotfoundexception e) {
            }
            if (c == null) {
                long t1 = system.nanotime();
                // 4. 每一层找不到，调用 findclass 方法（每个类加载器自己扩展）来加载
                c = findclass(name);
                // 5. 记录耗时
                sun.misc.perfcounter.getparentdelegationtime().addtime(t1 - t0);
                sun.misc.perfcounter.getfindclasstime().addelapsedtimefrom(t1);
                sun.misc.perfcounter.getfindclasses().increment();
            }
        }
        if (resolve) {
        	resolveclass(c);
        }
        return c;
    }
}

例如：

public class load5_3 {
    public static void main(string[] args) throws classnotfoundexception {
        class<?> aclass = load5_3.class.getclassloader()
        			.loadclass("cn.itcast.jvm.t3.load.h");
        system.out.println(aclass.getclassloader());
    }
}

执行流程为：

  • sun.misc.launcher$appclassloader // 1 处， 开始查看已加载的类，结果没有
  • sun.misc.launcher$appclassloader // 2 处，委派上级 sun.misc.launcher$extclassloader.loadclass()
  • sun.misc.launcher$extclassloader // 1 处，查看已加载的类，结果没有
  • sun.misc.launcher$extclassloader // 3 处，没有上级了，则委派 bootstrapclassloader 查找
  • bootstrapclassloader 是在 java_home/jre/lib 下找 h 这个类，显然没有
  • sun.misc.launcher$extclassloader // 4 处，调用自己的 findclass 方法，是在java_home/jre/lib/ext 下找 h 这个类，显然没有，回到 sun.misc.launcher$appclassloader 的 // 2 处
  • 继续执行到 sun.misc.launcher$appclassloader // 4 处，调用它自己的 findclass 方法，在 classpath 下查找，找到了

2.4 线程上下文类加载器

我们在使用 jdbc 时，都需要加载 driver 驱动，不知道你注意到没有，不写

class.forname("com.mysql.jdbc.driver")

也是可以让 com.mysql.jdbc.driver 正确加载的，你知道是怎么做的吗？ 让我们追踪一下源码：

public class drivermanager {
    // 注册驱动的集合
    private final static copyonwritearraylist<driverinfo> registereddrivers 
        = new copyonwritearraylist<>();
    // 初始化驱动
    static {
        loadinitialdrivers();
        println("jdbc drivermanager initialized");
    }

先不看别的，看看 drivermanager 的类加载器：

system.out.println(drivermanager.class.getclassloader());

打印 null，表示它的类加载器是 bootstrap classloader，会到 java_home/jre/lib 下搜索类，但 java_home/jre/lib 下显然没有 mysql-connector-java-5.1.47.jar 包，这样问题来了，在 drivermanager 的静态代码块中，怎么能正确加载 com.mysql.jdbc.driver 呢？

继续看 loadinitialdrivers() 方法：

private static void loadinitialdrivers() {
    string drivers;
    try {
        drivers = accesscontroller.doprivileged(new privilegedaction<string>() {
            public string run() {
            	return system.getproperty("jdbc.drivers");
            }
        });
    } catch (exception ex) {
    	drivers = null;
    }
    // 1）使用 serviceloader 机制加载驱动，即 spi
    accesscontroller.doprivileged(new privilegedaction<void>() {
    	public void run() {
            serviceloader<driver> loadeddrivers = serviceloader.load(driver.class);
            iterator<driver> driversiterator = loadeddrivers.iterator();
            try{
                while(driversiterator.hasnext()) {
                    driversiterator.next();
                }
            } catch(throwable t) {
                // do nothing
            }
            return null;
        }
    });
    println("drivermanager.initialize: jdbc.drivers = " + drivers);
    // 2）使用 jdbc.drivers 定义的驱动名加载驱动
    if (drivers == null || drivers.equals("")) {
    	return;
    }
    string[] driverslist = drivers.split(":");
    println("number of drivers:" + driverslist.length);
    for (string adriver : driverslist) {
        try {
            println("drivermanager.initialize: loading " + adriver);
            // 这里的 classloader.getsystemclassloader() 就是应用程序类加载器
            class.forname(adriver, true, classloader.getsystemclassloader());
        } catch (exception ex) {
        	println("drivermanager.initialize: load failed: " + ex);
        }
    }
}

先看 2）发现它最后是使用 class.forname 完成类的加载和初始化，关联的是应用程序类加载器，因此 可以顺利完成类加载

再看 1）它就是大名鼎鼎的 service provider interface （spi）

约定如下，在 jar 包的 meta-inf/services 包下，以接口全限定名名为文件，文件内容是实现类名称

这样就可以使用:

serviceloader<接口类型> allimpls = serviceloader.load(接口类型.class);
iterator<接口类型> iter = allimpls.iterator();
while(iter.hasnext()) {
	iter.next();
}

来得到实现类，体现的是【面向接口编程+解耦】的思想，在下面一些框架中都运用了此思想：

  • jdbc
  • servlet 初始化器
  • spring 容器
  • dubbo（对 spi 进行了扩展）

接着看 serviceloader.load 方法：

public static <s> serviceloader<s> load(class<s> service) {
    // 获取线程上下文类加载器
    classloader cl = thread.currentthread().getcontextclassloader();
    return serviceloader.load(service, cl);
}

线程上下文类加载器是当前线程使用的类加载器，默认就是应用程序类加载器，它内部又是由 class.forname 调用了线程上下文类加载器完成类加载，具体代码在 serviceloader 的内部类 lazyiterator 中：

private s nextservice() {
    if (!hasnextservice())
    	throw new nosuchelementexception();
    string cn = nextname;
    nextname = null;
    class<?> c = null;
    try {
    	c = class.forname(cn, false, loader);
    } catch (classnotfoundexception x) {
        fail(service, "provider " + cn + " not found");
    }
    if (!service.isassignablefrom(c)) {
        fail(service, "provider " + cn + " not a subtype");
    }
    try {
        s p = service.cast(c.newinstance());
        providers.put(cn, p);
        return p;
    } catch (throwable x) {
        fail(service, "provider " + cn + " could not be instantiated", x);
    }
    throw new error(); // this cannot happen
}

2.5 自定义类加载器

问问自己，什么时候需要自定义类加载器：

  • 1）想加载非 classpath 随意路径中的类文件
  • 2）都是通过接口来使用实现，希望解耦时，常用在框架设计
  • 3）这些类希望予以隔离，不同应用的同名类都可以加载，不冲突，常见于 tomcat 容器

步骤：

  • 继承 classloader 父类
  • 要遵从双亲委派机制，重写 findclass 方法 注意不是重写 loadclass 方法，否则不会走双亲委派机制
  • 读取类文件的字节码
  • 调用父类的 defineclass 方法来加载类
  • 使用者调用该类加载器的 loadclass 方法

3.总结

到此这篇关于jvm入门之类加载与字节码技术(类加载与类的加载器)的文章就介绍到这了,更多相关jvm 类加载与字节码技术内容请搜索www.887551.com以前的文章或继续浏览下面的相关文章希望大家以后多多支持www.887551.com！

上一篇 java Nio使用NioSocket客户端与服务端交互实现方式
下一篇 使用@ControllerAdvice同时配置过滤多个包

相关文章