1.JVM内存结构位置

2.类加载子系统

类加载子系统处于中间的位置，在外侧我们有了字节码文件以后，需要通过类加载子系统将.class文件读取，对.class文件的规格进行检查和判断，然后再将.class 里面的信息按照一定规则加载到我们的jvm内存当中进行存储。

可以说类加载子系统就是JVM虚拟机的一个入口所在，他是JVM与外界交互的处理组件。

类加载子系统作用：

1）类加载器子系统负责从文件系统或者网络中加载Class文件，class文件在文件开头有特定的文件标识。

2）ClassLoader只负责class文件的加载，至于它是否可以运行，则由Execution Engine决定。

3）加载的类信息存放于一块称为方法区的内存空间。除了类的信息外，方法区中还会存放运行时常量池信息，可能还包括字符串字面量和数字常量（这部分常量信息是Class文件中常量池部分的内存映射）

类加载过程：

作为一个字节码文件，进入到JVM内存中需要经历的步骤，如图所示：

类的加载过程又分为三个环节，下面挨个进行说明

3.类加载过程—加载阶段

将类的class文件读入内存，并为之创建一个java.lang.Class对象。此过程由类加载器完成

加载：

1、通过一个类的全限定名获取定义此类的二进制字节流

2、将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构

3、在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口

字节码的常见来源：

• 编译后本地.class文件

• 网络传输获取二进制流

• Jar/War包中解压后读取

• 动态运行生成，JDK动态代理/CGLib

• 从加密文件中获取，典型的防Class文件被反编译的保护措施

4.类加载过程—链接阶段

链接阶段又分为三个具体的子阶段：分别是验证、准备和解析

1、验证Verify：确保加载的类信息符合JVM规范，例如：以cafebabe开头，没有安全方面的问题。

2、准备Prepare：

（1）为类变量（static变量）分配内存并且设置该类变量的默认初始值，即零值

举例：变量a在准备阶段会赋初始值，但不是1，而是0，在初始化阶段会被赋值为 1

public class HelloApp {
    private static int a = 1;//prepare：a = 0 ---> initial : a = 1

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

（2）这里不包含用final修饰的static，因为final在编译的时候就会分配好了默认值，并且后期不会再对final变量进行修改，所以准备阶段会显式初始化

（3）注意：这里不会为实例变量分配初始化（因为这个时候还没有创建对象），类变量会分配在方法区中，而实例变量是会随着对象一起分配到Java堆中

3、解析Resolve：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。

5.类加载过程—初始化阶段

client()：

1、初始化阶段就是执行类构造器方法<clinit>()的过程

2、此方法不需定义，是javac编译器自动收集类中的所有类变量的赋值动作和静态代码块中的语句合并而来。也就是说，当我们代码中包含static变量的时候，就会有clinit方法

3、<clinit>()方法中的指令按语句在源文件中出现的顺序执行

4、<clinit>()不同于类的构造器。（关联：构造器是虚拟机视角下的<init>()）

5、若该类具有父类，JVM会保证子类的<clinit>()执行前，父类的<clinit>()已经执行完毕

6、虚拟机必须保证一个类的<clinit>()方法在多线程下被同步加锁

Jclasslib工具查看client()方法：

6.类加载器

这里的四者之间的关系是包含关系。不是上层下层，也不是子父类继承关系。

6.1.类加载器的作用

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

类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。

6.2.类加载器的分类

JVM支持两种类型的类加载器，分别为引导类加载器（Bootstrap ClassLoader）和自定义类加载器（User-Defined ClassLoader）。

从概念上来讲，自定义类加载器一般指的是程序中由开发人员自定义的一类类加载器，但是Java虚拟机规范却没有这么定义，而是将所有派生于抽象类ClassLoader的类加载器都划分为自定义类加载器。无论类加载器的类型如何划分，在程序中我们最常见的类加载器结构主要是如下情况：

public class ClassLoaderTest {
    public static void main(String[] args) {
        //获取系统类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2

        //获取其上层：扩展类加载器
        ClassLoader extClassLoader = systemClassLoader.getParent();
        System.out.println(extClassLoader);//sun.misc.Launcher$ExtClassLoader@1540e19d

        //获取其上层：获取不到引导类加载器
        ClassLoader bootstrapClassLoader = extClassLoader.getParent();
        System.out.println(bootstrapClassLoader);//null

        //对于用户自定义类来说：默认使用系统类加载器进行加载
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        System.out.println(classLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2

        //String类使用引导类加载器进行加载的。---> Java的核心类库都是使用引导类加载器进行加载的。
        ClassLoader classLoader1 = String.class.getClassLoader();
        System.out.println(classLoader1);//null
    }
}

• 我们尝试获取引导类加载器，获取到的值为 null ，这并不代表引导类加载器不存在，因为引导类加载器有 C/C++ 语言，我们获取不到
• 两次获取系统类加载器的值都相同：sun.misc.Launcher$AppClassLoader@18b4aac2 ，这说明系统类加载器是全局唯一的

（1）启动类加载器（引导类加载器，Bootstrap ClassLoader）

• 这个类加载使用`C/C++语言`实现的，嵌套在JVM内部。获取它的对象时往往返回null
• 它用来加载Java的核心库（JAVA_HOME/jre/lib/rt.jar或sun.boot.class.path路径下的内容）。用于提供JVM自身需要的类。
• 并不继承自java.lang.ClassLoader，没有父加载器。
• 出于安全考虑，Bootstrap启动类加载器只加载包名为java、javax、sun等开头的类
• 加载扩展类和应用程序类加载器，并指定为他们的父类加载器。

（2）扩展类加载器（Extension ClassLoader）

• Java语言编写，由sun.misc.Launcher$ExtClassLoader实现。
• 继承于ClassLoader类
• 父类加载器为启动类加载器
• 从java.ext.dirs系统属性所指定的目录中加载类库，或从JDK的安装目录的jre/lib/ext子目录下加载类库。如果用户创建的JAR放在此目录下，也会自动由扩展类加载器加载。

（3）应用程序类加载器（系统类加载器，AppClassLoader）

• java语言编写，由sun.misc.Launcher$AppClassLoader实现
• 继承于ClassLoader类
• 父类加载器为扩展类加载器
• 它负责加载环境变量classpath或系统属性 java.class.path 指定路径下的类库
• 应用程序中的类加载器默认是系统类加载器。一般来说，Java应用的类都是由它来完成加载。
• 它是用户自定义类加载器的默认父加载器
• 通过ClassLoader的getSystemClassLoader()方法可以获取到该类加载器

（4）用户自定义类加载器

• 在Java的日常应用程序开发中，类的加载几乎是由上述3种类加载器相互配合执行的。在必要时，我们还可以自定义类加载器，来定制类的加载方式。
• 体现Java语言强大生命力和巨大魅力的关键因素之一便是，Java开发者可以自定义类加载器来实现类库的动态加载，加载源可以是本地的JAR包，也可以是网络上的远程资源。
• 同时，自定义加载器能够实现`应用隔离`，例如 Tomcat，Spring等中间件和组件框架都在内部实现了自定义的加载器，并通过自定义加载器隔离不同的组件模块这种机制比C/C++程序要好太多，想不修改C/C++程序就能为其新增功能，几乎是不可能的，仅仅一个兼容性便能阻挡住所有美好的设想。
• 自定义类加载器通常需要继承于ClassLoader。

6.3.什么时候需要自定义类加载器

1、隔离加载类（比如说我假设现在Spring框架，和RocketMQ有包名路径完全一样的类，类名也一样，这个时候类就冲突了。不过一般的主流框架和中间件都会自定义类加载器，实现不同的框架，中间件之间是隔离的）

2、修改类加载的方式

3、扩展加载源（还可以考虑从数据库中加载类，路由器等等不同的地方）

4、防止源码泄漏（对字节码文件进行解密，自己用的时候通过自定义类加载器来对其进行解密）

6.4.如何自定义类加载器？

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

2、在JDK1.2之前，在自定义类加载器时，总会去继承ClassLoader类并重写loadClass()方法，从而实现自定义的类加载类，但是在JDK1.2之后已不再建议用户去覆盖loadClass()方法，而是建议把自定义的类加载逻辑写在findclass()方法中

3、在编写自定义类加载器时，如果没有太过于复杂的需求，可以直接继承URIClassLoader类，这样就可以避免自己去编写findclass()方法及其获取字节码流的方式，使自定义类加载器编写更加简洁。

7.双亲委派机制

7.1.双亲委派机制原理

Java虚拟机对class文件采用的是按需加载的方式，也就是说当需要使用该类时才会将它的class文件加载到内存生成class对象。而且加载某个类的class文件时，Java虚拟机采用的是双亲委派模式，即把请求交由父类处理，它是一种任务委派模式

1、如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行；

2、如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器；

3、如果父类加载器可以完成类加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，这就是双亲委派模式。

4、父类加载器一层一层往下分配任务，如果子类加载器能加载，则加载此类，如果将加载任务分配至系统类加载器也无法加载此类，则抛出异常

7.2.双亲委派机制演示

代码演示1：

1、我们自己建立一个 java.lang.String 类，写上 static 代码块

package java.lang;

public class String {
    static{
        System.out.println("我是自定义的String类的静态代码块");
    }
}

2、在另外的程序中加载 String 类，看看加载的 String 类是 JDK 自带的 String 类，还是我们自己编写的 String 类

public class StringTest {
    public static void main(String[] args) {
        java.lang.String str = new java.lang.String();
        System.out.println("hello,fblinux.com");

        StringTest test = new StringTest();
        System.out.println(test.getClass().getClassLoader());
    }
}

输出结果：

hello,fblinux.com
jdk.internal.loader.ClassLoaders$AppClassLoader@251a69d7

程序并没有输出我们静态代码块中的内容，可见仍然加载的是 JDK 自带的 String 类。

把刚刚的类改一下，在运行

package java.lang;

public class String {
    static{
        System.out.println("我是自定义的String类的静态代码块");
    }
    //错误: 在类 JDK 自带的java.lang.String 中找不到 main 方法
    public static void main(String[] args) {
        System.out.println("hello,String");
    }
}

由于双亲委派机制一直找父类，所以最后找到了Bootstrap ClassLoader，Bootstrap ClassLoader找到的是 JDK 自带的 String 类，在那个String类中并没有 main() 方法，所以就报了上面的错误。

代码演示2：

package java.lang;

public class FbStart {
    public static void main(String[] args) {
        System.out.println("hello!");
    }
}

即使类名没有重复，也禁止使用java.lang这种包名。这是一种保护机制

7.3.双亲委派机制的优势

• 避免类的重复加载
• 保护程序安全，防止核心API被随意篡改
  • 自定义类：自定义java.lang.String 没有被加载。
  • 自定义类：java.lang.FbStart（报错：阻止创建 java.lang开头的类）

7.4.沙箱安全机制

1、自定义String类时：在加载自定义String类的时候会率先使用引导类加载器加载，而引导类加载器在加载的过程中会先加载jdk自带的文件（rt.jar包中java.lang.String.class），报错信息说没有main方法，就是因为加载的是rt.jar包中的String类。

2、这样可以保证对java核心源代码的保护，这就是沙箱安全机制。

7.5.如何判断两个class对象是否相同？

在JVM中表示两个class对象是否为同一个类存在两个必要条件：

1、类的完整类名必须一致，包括包名

2、加载这个类的ClassLoader（指ClassLoader实例对象）必须相同

3、换句话说，在JVM中，即使这两个类对象（class对象）来源同一个Class文件，被同一个虚拟机所加载，但只要加载它们的ClassLoader实例对象不同，那么这两个类对象也是不相等的

7.6.对类加载器的引用

1、JVM必须知道一个类型是由启动加载器加载的还是由用户类加载器加载的

2、如果一个类型是由用户类加载器加载的，那么JVM会将这个类加载器的一个引用作为类型信息的一部分保存在方法区中

3、当解析一个类型到另一个类型的引用的时候，JVM需要保证这两个类型的类加载器是相同的

转载请注明：西门飞冰的博客 » JVM—类加载子系统