JVM之类加载流程

置顶 于 2020-03-20 21:21:12 发布
阅读量387 收藏
点赞数
分类专栏： # Jvm
原文链接：https://juejin.im/post/5b4deaa3e51d4519596b7f27#heading-34
版权

前言

本文将由浅及深，介绍Java类加载的过程和原理，进一步对类加载器的进行源码分析，完成一个自定义的类加载器。

正文

(一). 类加载器是什么

类加载器简言之，就是用于把.class文件中的字节码信息转化为具体的java.lang.Class对象的过程的工具。

具体过程：

  1. 在实际类加载过程中，JVM会将所有的.class字节码文件中的二进制数据读入内存中，导入运行时数据区的方法区中。
  2. 当一个类首次被主动加载或被动加载时，类加载器会对此类执行类加载的流程 – 加载、连接（验证、准备、解析）、初始化。
  3. 如果类加载成功，堆内存中会产生一个新的Class对象，Class对象封装了类在方法区内的数据结构。

Class对象的创建过程描述：

(二). 类加载的过程

类加载的过程分为三个步骤(五个阶段) ：加载 -> 连接（验证、准备、解析）-> 初始化。

加载、验证、准备和初始化这四个阶段发生的顺序是确定的，而解析阶段可以在初始化阶段之后发生，也称为动态绑定或晚期绑定。

类加载的过程描述：

1. 加载

加载：查找并加载类的二进制数据的过程。

加载的过程描述：

  1. 通过类的全限定名定位.class文件，并获取其二进制字节流。
  2. 把字节流所代表的静态存储结构转换为方法区的运行时数据结构。
  3. 在Java堆中生成一个此类的java.lang.Class对象，作为方法区中这些数据的访问入口。

下面提到的自定义类加载器，主要也就是覆盖此步骤中的方法

2. 连接

连接：包括验证、准备、解析三步。

a). 验证

验证：确保被加载的类的正确性。验证是连接阶段的第一步，用于确保Class字节流中的信息是否符合虚拟机的要求。

具体验证形式：

  1. 文件格式验证：验证字节流是否符合Class文件格式的规范；例如：是否以0xCAFEBABE开头、主次版本号是否在当前虚拟机的处理范围之内、常量池中的常量是否有不被支持的类型。
  2. 元数据验证：对字节码描述的信息进行语义分析（注意：对比javac编译阶段的语义分析），以保证其描述的信息符合Java语言规范的要求；例如：这个类是否有父类，除了java.lang.Object之外。
  3. 字节码验证：通过数据流和控制流分析，确定程序语义是合法的、符合逻辑的。
  4. 符号引用验证：确保解析动作能正确执行。

b). 准备

准备：为类的静态变量分配内存，并将其初始化为默认值。准备过程通常分配一个结构用来存储类信息，这个结构中包含了类中定义的成员变量，方法和接口信息等。

具体行为：

  1. 这时候进行内存分配的仅包括类变量(static)，而不包括实例变量，实例变量会在对象实例化时随着对象一块分配在Java堆中。
  2. 这里所设置的初始值通常情况下是数据类型默认的零值（如0、0L、null、false等），而不是被在Java代码中被显式赋值。

c). 解析

解析：把类中对常量池内的符号引用转换为直接引用。

解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符等7类符号引用进行。

3. 初始化

初始化：对类静态变量赋予正确的初始值 (注意和连接时的解析过程区分开)。

初始化的目标

  1. 实现对声明类静态变量时指定的初始值的初始化；
  2. 实现对使用静态代码块设置的初始值的初始化。

初始化的步骤

  1. 如果此类没被加载、连接，则先加载、连接此类；
  2. 如果此类的直接父类还未被初始化，则先初始化其直接父类；
  3. 如果类中有初始化语句，则按照顺序依次执行初始化语句。

初始化的时机

  1. 创建类的实例(new关键字)；
  2. java.lang.reflect包中的方法(如：Class.forName(“xxx”))；
  3. 对类的静态变量进行访问或赋值；
  4. 访问调用类的静态方法；
  5. 初始化一个类的子类，父类本身也会被初始化；
  6. 作为程序的启动入口，包含main方法(如：SpringBoot入口类)。

(三). 类的主动引用和被动引用

主动引用

主动引用：在类加载阶段，只执行加载、连接操作，不执行初始化操作。

主动引用的几种形式

  1. 创建类的实例(new关键字)；
  2. java.lang.reflect包中的方法(如：Class.forName(“xxx”))；
  3. 对类的静态变量进行访问或赋值；
  4. 访问调用类的静态方法；
  5. 初始化一个类的子类，父类本身也会被初始化；
  6. 作为程序的启动入口，包含main方法(如：SpringBoot入口类)。

主动引用1 - main方法在初始类中

代码示例：

public class OptimisticReference0 {
    static {
        System.out.println(OptimisticReference0.class.getSimpleName() + " is referred!");
    }

    public static void main(String[] args) {
        System.out.println();
    }
}

运行结果：

OptimisticReference0 is referred!

主动引用2 – 创建子类会触发父类的初始化

代码示例：

public class OptimisticReference1 {
    public static class Parent {
        static {
            System.out.println(Parent.class.getSimpleName() + " is referred!");
        }
    }

    public static class Child extends Parent {
        static {
            System.out.println(Child.class.getSimpleName() + " is referred!");
        }
    }

    public static void main(String[] args) {
        new Child();
    }
}

运行结果：

Parent is referred! Child is referred!

主动引用3 – 访问一个类静态变量

代码示例：

public class OptimisticReference2 {
    public static class Child {
        protected static String name;
        static {
            System.out.println(Child.class.getSimpleName() + " is referred!");
            name = "Child";
        }
    }

    public static void main(String[] args) {
        System.out.println(Child.name);
    }
}

运行结果：

Child is referred! Child

主动引用4 – 对类的静态变量进行赋值

代码示例：

public class OptimisticReference3 {
    public static class Child {
        protected static String name;
        static {
            System.out.println(Child.class.getSimpleName() + " is referred!");
        }
    }

    public static void main(String[] args) {
        Child.name = "Child";
    }
}

运行结果：

Child is referred!

主动引用5 – 使用java.lang.reflect包提供的反射机制

代码示例：

public class OptimisticReference4 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class.forName("org.ostenant.jdk8.learning.examples.reference.optimistic.Child");
    }
}

运行结果：

Child is referred!

被动引用

被动引用： 在类加载阶段，会执行加载、连接和初始化操作。

被动引用的几种形式：

  1. 通过子类引用父类的的静态字段，不会导致子类初始化；
  2. 定义类的数组引用而不赋值，不会触发此类的初始化；
  3. 访问类定义的常量，不会触发此类的初始化。

被动引用1 – 子类引用父类的的静态字段，不会导致子类初始化

代码示例：

public class NegativeReference0 {
    public static class Parent {
        public static String name = "Parent";
        static {
            System.out.println(Parent.class.getSimpleName() + " is referred!");
        }
    }

    public static class Child extends Parent {
        static {
            System.out.println(Child.class.getSimpleName() + " is referred!");
        }
    }

    public static void main(String[] args) {
        System.out.println(Child.name);
    }
}

运行结果：

Parent is referred! Parent

被动引用2 – 定义类的数组引用而不赋值，不会触发此类的初始化

代码示例：

public class NegativeReference1 {
    public static class Child {
        static {
            System.out.println(Child.class.getSimpleName() + " is referred!");
        }
    }

    public static void main(String[] args) {
        Child[] childs = new Child[10];
    }
}

运行结果：

无输出

被动引用3 – 访问类定义的常量，不会触发此类的初始化

示例代码：

public class NegativeReference2 {
    public static class Child {
        public static final String name = "Child";
        static {
            System.out.println(Child.class.getSimpleName() + " is referred!");
        }
    }

    public static void main(String[] args) {
        System.out.println(Child.name);
    }
}

运行结果：

Child

(四). 三种类加载器

类加载器：类加载器负责加载程序中的类型（类和接口），并赋予唯一的名字予以标识。

类加载器的组织结构

类加载器的关系

  1. Bootstrap Classloader 是在Java虚拟机启动后初始化的。
  2. Bootstrap Classloader 负责加载 ExtClassLoader，并且将 ExtClassLoader的父加载器设置为 Bootstrap Classloader
  3. Bootstrap Classloader 加载完 ExtClassLoader 后，就会加载 AppClassLoader，并且将 AppClassLoader 的父加载器指定为 ExtClassLoader。

类加载器的作用

Class Loader实现方式具体实现类负责加载的目标
Bootstrap LoaderC++由C++实现%JAVA_HOME%/jre/lib/rt.jar以及-Xbootclasspath参数指定的路径以及中的类库
Extension ClassLoaderJavasun.misc.Launcher$ExtClassLoader%JAVA_HOME%/jre/lib/ext路径下以及java.ext.dirs系统变量指定的路径中类库
Application ClassLoaderJavasun.misc.Launcher$AppClassLoaderClasspath以及-classpath、-cp指定目录所指定的位置的类或者是jar文档，它也是Java程序默认的类加载器

类加载器的特点

  • 层级结构：Java里的类装载器被组织成了有父子关系的层级结构。Bootstrap类装载器是所有装载器的父亲，注意不是继承关系。
  • 代理模式： 基于层级结构，类的代理可以在装载器之间进行代理。当装载器装载一个类时，首先会检查它在父装载器中是否进行了装载。如果上层装载器已经装载了这个类，这个类会被直接使用。反之，类装载器会请求装载这个类
  • 可见性限制：一个子装载器可以查找父装载器中的类，但是一个父装载器不能查找子装载器里的类。
  • 不允许卸载：类装载器可以装载一个类但是不可以卸载它，不过可以删除当前的类装载器，然后创建一个新的类装载器装载。

类加载器的隔离问题

每个类装载器都有一个自己的命名空间用来保存已装载的类。当一个类装载器装载一个类时，它会通过保存在命名空间里的类全局限定名(Fully Qualified Class Name) 进行搜索来检测这个类是否已经被加载了。

JVM 及 Dalvik 对类唯一的识别是 ClassLoader id + PackageName + ClassName，所以一个运行程序中是有可能存在两个包名和类名完全一致的类的。并且如果这两个类不是由一个 ClassLoader 加载，是无法将一个类的实例强转为另外一个类的，这就是 ClassLoader 隔离性。

为了解决类加载器的隔离问题，JVM引入了双亲委托机制。

(五). 双亲委托机制

核心思想：其一，自底向上检查类是否已加载；其二，自顶向下尝试加载类。

具体加载过程

  1. 当AppClassLoader加载一个class时，它首先不会自己去尝试加载这个类，而是把类加载请求委派给父类加载器ExtClassLoader去完成。
  2. 当ExtClassLoader加载一个class时，它首先也不会自己去尝试加载这个类，而是把类加载请求委派给BootStrapClassLoader去完成。
  3. 如果BootStrapClassLoader加载失败（例如在%JAVA_HOME%/jre/lib里未查找到该class），会使用ExtClassLoader来尝试加载；
  4. 如果ExtClassLoader也加载失败，则会使用AppClassLoader来加载，如果AppClassLoader也加载失败，则会报出异常ClassNotFoundException。

每个儿子都很懒，每次有活就丢给父亲去干，直到父亲说这件事我也干不了时，儿子才会自己想办法去完成。

源码分析

ClassLoader.class

1.loadClass()：通过指定类的全限定名称，由类加载器检测、装载、创建并返回该类的java.lang.Class对象。

protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException
{
    synchronized (getClassLoadingLock(name)) {
        //首先，根据name检查类是否已经加载，若已加载，会直接返回
        Class<?> c = findLoadedClass(name);
        if (c == null) {
            long t0 = System.nanoTime();
            try {
                if (parent != null) {
                    //若当前类加载器有父加载器，则调用其父加载器的loadClass()
                    c = parent.loadClass(name, false);
                } else {
                    //若当前类加载器的parent为空，则调用findBootstrapClassOrNull()
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
            }
        
            if (c == null) {
                // 1.如果到这里c依然为空的话，表示一直到最顶层的父加载器也没有找到已加载的c，那就会调用findClass进行查找
                // 2.在findClass的过程中，如果指定目录下没有，就会抛出异常ClassNotFoundException
                // 3.抛出异常后，此层调用结束，接着其子加载器继续进行findClass操作
                long t1 = System.nanoTime();
                c = findClass(name);

                sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                sun.misc.PerfCounter.getFindClasses().increment();
            }
        }
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }
}

ClassLoader通过loadClass()方法实现了双亲委托机制，用于类的动态加载。

loadClass()本身是一个递归向上调用的过程。

  • 自底向上检查类是否已加载

    1. 先通过findLoadedClass()方法从最底端类加载器开始检查类是否已经加载。
    2. 如果已经加载，则根据resolve参数决定是否要执行连接过程，并返回Class对象。
    3. 如果没有加载，则通过parent.loadClass()委托其父类加载器执行相同的检查操作(默认不做连接处理)。
    4. 直到顶级类加载器，即parent为空时，由findBootstrapClassOrNull()方法尝试到Bootstrap ClassLoader中检查目标类。

  • 自顶向下尝试加载类

    1. 如果仍然没有找到目标类，则从Bootstrap ClassLoader开始，通过findClass()方法尝试到对应的类目录下去加载目标类。
    2. 如果加载成功，则根据resolve参数决定是否要执行连接过程，并返回Class对象。
    3. 如果加载失败，则由其子类加载器尝试加载，直到最底端类加载器也加载失败，最终抛出ClassNotFoundException。

2.findLoadedClass()

    protected final Class<?> findLoadedClass(String string) {
        if (!this.checkName(string)) {
            return null;
        }
        return this.findLoadedClass0(string);
    }

 查找当前类加载器的缓存中是否已经加载目标类。findLoadedClass()实际调用了底层的native方法findLoadedClass0()。

3.findBootstrapClassOrNull()

private Class<?> findBootstrapClassOrNull(String string) {
        if (!this.checkName(string)) {
            return null;
        }
        return this.findBootstrapClass(string);
}

 查找最顶端Bootstrap类加载器的是否已经加载目标类。同样，findBootstrapClassOrNull()实际调用了底层的native方法findBootstrapClass()。

4.findClass()

 protected Class<?> findClass(String string) throws ClassNotFoundException {
        throw new ClassNotFoundException(string);
 }

ClassLoader是java.lang包下的抽象类，也是所有类加载器(除了Bootstrap)的基类，findClass()是ClassLoader对子类提供的加载目标类的抽象方法。

注意：Bootstrap ClassLoader并不属于JVM的层次，它不遵守ClassLoader的加载规则，Bootstrap classLoader并没有子类。

5.defineClass()

    protected final Class<?> defineClass(String string, byte[] arrby, int n, int n2, ProtectionDomain protectionDomain) throws ClassFormatError {
        protectionDomain = this.preDefineClass(string, protectionDomain);
        String string2 = this.defineClassSourceLocation(protectionDomain);
        Class<?> class_ = this.defineClass1(string, arrby, n, n2, protectionDomain, string2);
        this.postDefineClass(class_, protectionDomain);
        return class_;
    }

 defineClass()是ClassLoader向子类提供的方法，它可以将.class文件的二进制数据转换为合法的java.lang.Class对象。

为什么要设计双亲委派机制

  1. 避免类的重复加载：当父加载器已经加载过该类时，就没有必要让子加载器在加载一次，保证被加载类的唯一性
  2. 沙箱安全机制：防止核心api库被随意篡改

(六). 类的动态加载

类的几种加载方式

  • 通过命令行启动时由JVM初始化加载；
  • 通过Class.forName()方法动态加载；
  • 通过ClassLoader.loadClass()方法动态加载。

Class.forName()和ClassLoader.loadClass()

  • Class.forName()：把类的.class文件加载到JVM中，对类进行解释的同时执行类中的static静态代码块；
  • ClassLoader.loadClass()：只是把.class文件加载到JVM中，不会执行static代码块中的内容，只有在newInstance才会去执行。

(七). 对象的初始化

对象的初始化顺序

静态变量/静态代码块 -> 普通代码块 -> 构造函数

  1. 父类静态变量和静态代码块（先声明的先执行）；
  2. 子类静态变量和静态代码块（先声明的先执行）；
  3. 父类普通成员变量和普通代码块（先声明的先执行）；
  4. 父类的构造函数；
  5. 子类普通成员变量和普通代码块（先声明的先执行）；
  6. 子类的构造函数。

对象的初始化示例

Parent.java

public class Parent {
	protected static String CLASS_NAME;
	protected static String CLASS_LOADER_NAME;
	protected String instanceID;

	// 1.先执行静态变量和静态代码块(静态代码域，在类的加载的时候调用一次，整个生命周期只会调用一次)
	static {
		CLASS_NAME = Parent.class.getName();
		CLASS_LOADER_NAME = Parent.class.getClassLoader().toString();
		System.out.println("step 1:" + CLASS_NAME + " is loaded by " + CLASS_LOADER_NAME);
	}
	// 3.然后执行变量和普通代码块(普通代码域，在类的每个对象创建的时候调用)
	{
		instanceID = this.toString();
		System.out.println("step 3:Parent instance is created:" + CLASS_LOADER_NAME + "->" + instanceID);
	}

	// 4.然后执行构造方法
	public Parent() {
		System.out.println("step 4:Parent instance:" + instanceID + ",construtor is invoked");
	}
}

Children.java

public class Children extends Parent {

	// 2.先执行静态变量和静态代码块(静态代码域，在类的加载的时候调用一次，整个生命周期只会调用一次)
	static {
		CLASS_NAME = Children.class.getName();
		CLASS_LOADER_NAME = Children.class.getClassLoader().toString();
		System.out.println("step 2:" + CLASS_NAME + " is loaded by " + CLASS_LOADER_NAME);
	}
	// 5.然后执行变量和普通代码块(普通代码域，在类的每个对象创建的时候调用)
	{
		instanceID = this.toString();
		System.out.println("step 5:Children instance is created:" + CLASS_LOADER_NAME + "->" + instanceID);
	}

	// 6.然后执行构造方法
	public Children() {
		System.out.println("step 6:Children instance:" + instanceID + ",construtor is invoked");
	}
}

Tester.java

public class Tester {
	@Test
	public void test(){
		new Children();
	}
}

测试结果：

step 1:com.yj.jvm.Parent is loaded by sun.misc.Launcher$AppClassLoader@42a57993
step 2:com.yj.jvm.Children is loaded by sun.misc.Launcher$AppClassLoader@42a57993
step 3:Parent instance is created:sun.misc.Launcher$AppClassLoader@42a57993->com.yj.jvm.Children@2328c243
step 4:Parent instance:com.yj.jvm.Children@2328c243,construtor is invoked
step 5:Children instance is created:sun.misc.Launcher$AppClassLoader@42a57993->com.yj.jvm.Children@2328c243
step 6:Children instance:com.yj.jvm.Children@2328c243,construtor is invoked

测试结果表明：JVM在创建对象时，遵守以上对象的初始化顺序。

(八). 自定义类加载器

编写自己的类加载器

在源码分析阶段，我们已经解读了如何实现自定义类加载器，现在我们开始实现自己的类加载器。

Step 1：定义待加载的目标类People.java

public class People {
	private String name;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

Step 2：实现自定义类加载器MyClassLoader，重写findClass方法

各种自定义类加载器的主要思路：

  1. 覆盖默认的通过类的全限定名定位.class文件，获取其二进制字节流的findClass方法。比如我们可以从自定义文件夹中获取，也可以从远程网络上面获取.class文件的二进制字节流
  2. 在findClass方法中，调用defineClass把步骤1获得到的字节流，所代表的静态存储结构转换为方法区的运行时数据结构
package com.yj.jvm;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;

public class MyClassLoader extends ClassLoader {

	private String classpath;

	public MyClassLoader(String classpath) {

		this.classpath = classpath;
	}

	@Override
	protected Class<?> findClass(String name) throws ClassNotFoundException {
		try {
			byte[] classDate = getDate(name);
			// byte[] classData = downloadClassData(name); // 从远程下载
			if (classDate == null) {
				super.findClass(name);
			} else {
				// defineClass方法将字节码转化为类
				return defineClass(name, classDate, 0, classDate.length);
			}

		} catch (IOException e) {

			e.printStackTrace();
		}

		return super.findClass(name);
	}

	// 返回类的字节码
	private byte[] getDate(String className) throws IOException {
		InputStream in = null;
		ByteArrayOutputStream out = null;
		String path = classpath + File.separatorChar + className.replace('.', File.separatorChar) + ".class";
		try {
			in = new FileInputStream(path);
			out = new ByteArrayOutputStream();
			byte[] buffer = new byte[2048];
			int len = 0;
			while ((len = in.read(buffer)) != -1) {
				out.write(buffer, 0, len);
			}
			return out.toByteArray();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} finally {
			in.close();
			out.close();
		}
		return null;
	}

	private byte[] downloadClassData(String name) {
		// 从 localhost 下载 .class 文件
		String path = "http://localhost" + File.separatorChar + "java" + File.separatorChar
				+ name.replace('.', File.separatorChar) + ".class";

		try {
			URL url = new URL(path);
			InputStream ins = url.openStream();
			ByteArrayOutputStream baos = new ByteArrayOutputStream();
			int bufferSize = 4096;
			byte[] buffer = new byte[bufferSize];
			int bytesNumRead = 0;
			while ((bytesNumRead = ins.read(buffer)) != -1) {
				baos.write(buffer, 0, bytesNumRead); // 把下载的二进制数据存入
														// ByteArrayOutputStream
			}
			return baos.toByteArray();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
}

Step 2：对People.java源文件执行手动编译，在同级目录下生成.class文件，拷贝到D:\lib\com\yj\jvm目录下

Step 3：TestMyClassLoader开始验证，观察类的加载是否成功了

public class TestMyClassLoader {

	public static void main(String[] args) throws Exception {
		// 自定义类加载器的加载路径
		MyClassLoader myClassLoader = new MyClassLoader("D:\\lib");
		// 包名+类名
		Class c = myClassLoader.loadClass("com.yj.jvm.People");
		if (c != null) {
			Object obj = c.newInstance();
			Method method = c.getMethod("setName", String.class);
			method.invoke(obj, "abc");
			System.out.println("obj:"+obj+",ClassLoader:"+c.getClassLoader().toString());
		}
	}
}

 观察输出

obj:People [name=abc],ClassLoader:com.yj.jvm.MyClassLoader@4aa298b7

 

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值