JVM学习(二)--类加载器子系统

news/2024/7/8 12:47:29

目录

一、内存结构

二、类的加载器及类的加载过程

类加载器的分类

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

扩展类加载器（Extension ClassLoader）

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

用户自定义类的加载器

关于ClassLoader

三、双亲委派机制

1、简介

2、工作原理

3、优势

沙箱安全机制

类的主动使用和被动使用

一、内存结构

内存结构的简图

二、类的加载器及类的加载过程

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

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

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

加载阶段：

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

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

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

链接阶段：

验证（Verify）：

目的在于确保class文件的字节流中包含信息符合当前虚拟机要求，保证被加载类的正确性，不会危害虚拟机自身安全。

主要包括四种验证：文件格式验证，元数据验证，字节码验证，符号引用验证。

准备（Prepare）：

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

这里不包含用final修饰的static，因为final在编译的时候就会分配了，准备阶段会显式初始化。

这里不会为实例变量分配初始化，类变量会分配在方法区中，而实例变量是会随着对象一起分配到Java堆中。

解析（Resolve）：

将常量池内的符号引用转换为直接引用的过程。

事实上，解析操作往往会伴随着JVM在执行完初始化之后再执行。

符号引用就是一组符号来描述所引用的目标，符号引用在字面量形式明确定义在<Java虚拟机规范>的Class文件格式中。直接引用就是直接指向目标的指针、相对偏移量或一个间接定位到目标的句柄。

解析动作主要针对类或接口、字段、类方法、接口方法、方法类型等。对应常量池中的CONSTANT_CLASS_INFO、CONSTANT_FIELDREF_INFO、CONSTANT_METHODREF_INFO等。

初始化阶段：

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

此方法不需定义，是javac编译器自动收集类中的所有类变量的赋值动作和静态代码块中的语句合并而来。

构造器方法中指令按语句在源文件中出现的顺序执行。

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

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

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

类加载器的分类

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

    static class ExtClassLoader extends URLClassLoader {
        private static volatile Launcher.ExtClassLoader instance;
.....
    static class AppClassLoader extends URLClassLoader {
        final URLClassPath ucp = SharedSecrets.getJavaNetAccess().getURLClassPath(this);

 ExtClassLoader 和 AppClassLoader都间接继承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@8efb846
        //获取其上层,获取不到引导类加载器
        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 stringClassLoader = String.class.getClassLoader();
        System.out.println(stringClassLoader);//null
    }
}

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

      这个类加载使用C/C++语言实现的，嵌套在JVM内部。

      它用来加载Java的核心库(JAVA_HOME/jre/lib/rt.jar、resources.jar或sun.boot.class.path路径下的内容)，用于提供JVM自身需要的类。

      并不继承自java.lang.ClassLoader，没有父加载器。

      加载扩展类和应用类加载器，并指定为他们的父类加载器。

      出于安全考虑，Bootstrap启动类加载器只加载包名为java、javax、sun等开头的类。

扩展类加载器（Extension ClassLoader）

      Java语言编写，由sun.misc.Launcher$ExtClassLoader实现。

      派生于ClassLoader类

      父类加载器为启动类加载器。

      从java.ext.dirs系统属性所指定的目录中加载类库，或从JDK的安装目录的jre/lib/ext子目录（扩展目录）下加载类库。如果用户创建的JAR放在此目录下，也会自动由扩展类加载器加载。

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

      java语言编写，由sun.misc.Launcher$AppClassLoader实现

      派生于ClassLoader类

      父类加载器为扩展类加载器

      它负责加载环境变量classpath或系统属性 java.class.path指定路径下的类库

      该类加载器是程序中默认的类加载器，一般来说，Java应用的类都是由它来完成加载。

      通过ClassLoader#getSystemClassLoader()方法可以获取到该类加载器。

import sun.security.ec.CurveDB;

import java.net.URL;
import java.security.Provider;

public class ClassLoaderTest1 {

    public static void main(String[] args) {
        System.out.println("========启动类加载器========");
        //获取BootstrapClassLoader能够加载的api的路径
        URL[] urls = sun.misc.Launcher.getBootstrapClassPath().getURLs();
        for (URL url:urls) {
            System.out.println(url.toExternalForm());
        }

        //从上面的路径中选择一个类，看看它的类加载器是？引导类加载器
        ClassLoader classLoader = Provider.class.getClassLoader();
        System.out.println(classLoader);//null

        System.out.println("========启动类加载器========");
        String extDirs = System.getProperty("java.ext.dirs");
        for (String path:extDirs.split(";")) {
            System.out.println(path);
        }
        //从上面的路径中选择一个类，看看它的类加载器是？扩展类加载器
        ClassLoader extclassLoader = CurveDB.class.getClassLoader();
        System.out.println(extclassLoader);//sun.misc.Launcher$ExtClassLoader@85ede7b
    }
}

用户自定义类的加载器

在必要时，可以自定义类的加载器，来定制类的加载方式。

为什么要自定义类的加载器？

隔离加载类

修改类加载的方式

扩展加载源

防止源码泄露

用户自定义类加载器实现步骤：

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

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

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

import java.io.FileNotFoundException;

public class CustomClassLoader extends ClassLoader {

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

        byte[] result = getClassFromCustomPath(name);
        if (result == null){
            try {
                throw new FileNotFoundException(name);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }else {
            return defineClass(name,result,0,result.length);
        }
        throw new ClassNotFoundException(name);
    }

    private byte[] getClassFromCustomPath(String name) {
        //略
        return null;
    }

    public static void main(String[] args) {
        CustomClassLoader customClassLoader=new CustomClassLoader();
        try {
            Class<?> clazz = Class.forName("One",true,customClassLoader);
            Object obj=clazz.newInstance();
            System.out.println(obj.getClass().getClassLoader());
        }catch (Exception e){
            e.printStackTrace();
        }
    }

}

关于ClassLoader

ClassLoader类，它是一个抽象类，其后所有的类加载器都继承自ClassLoader（不包括启动类加载器）

public abstract class ClassLoader extends Object

常用方法
1、ClassLoader getParent() :返回该类加载器的超类加载器
2、类<?> loadClass(String name) :加载名称为name的类，返回结果为java.lang.Class类的实例
3、protected 类<?> findClass(String name) :查找名称为name的类，返回结果为java.lang.Class
类的实例
4、protected 类<?> findLoadedClass(String name) :查找名称为name的已经被加载过的类，
返回结果为java.lang.Class类的实例
5、protected 类<?> defineClass(String name, byte[] b, int off, int len):把字节数组b中的
内容转换为一个Java类，返回结果为java.lang.Class类的实例
6、protected void resolveClass(类<?> c) :连接指定的一个Java类

获取ClassLoader的途径

1、获取当前类的ClassLoader
clazz.getClassLoader();
2、获取当前线程上下文的ClassLoader
Thread.currentThread().getContextClassLoader()
3、获取系统的ClassLoader
ClassLoader.getSystemClassLoader()
4、获取调用者的ClassLoader
DriverManager.getCallerClassLoader()

三、双亲委派机制

1、简介

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

咱们可以测试一下，自己创建一个java.lang包，下面创建一个类String。

package java.lang;

public class String {
    static {
        System.out.println("我是自定义的String类的静态代码块");
    }
}
public class StringTest {
    public static void main(String[] args) {
        String str= new String();
        System.out.println("hello world");
    }
}

测试结果：hello world

并没有走我们自定义String类。这里其实就体现了“双亲委派机制”。其实也是对我们项目的保护。

2、工作原理

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

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

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

package java.lang;

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

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

自定义String类，main方法，进行执行：结果

错误: 在类 java.lang.String 中找不到 main 方法, 请将 main 方法定义为:
   public static void main(String[] args)
否则 JavaFX 应用程序类必须扩展javafx.application.Application

核心Api String类中没有main方法。被引导类加载器加载完。我们自定义的String类没被加载。

3、优势

避免类的重复加载

保护程序安全，防止核心API被随意篡改，例如：自定义类：java.lang.String

若自定义的类在java.lang下没有的话，进行执行什么效果呢？

package java.lang;

public class SSLwz {

    public static void main(String[] args) {
        System.out.println("hello,杀神lwz");
    }
}

结果：抛出异常，禁止包名为java.lang。进行保护程序安全。

java.lang.SecurityException: Prohibited package name: java.lang
	at java.lang.ClassLoader.preDefineClass(ClassLoader.java:662)
	at java.lang.ClassLoader.defineClass(ClassLoader.java:761)
	at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:142)
	at java.net.URLClassLoader.defineClass(URLClassLoader.java:468)
	at java.net.URLClassLoader.access$100(URLClassLoader.java:74)
	at java.net.URLClassLoader$1.run(URLClassLoader.java:369)
	at java.net.URLClassLoader$1.run(URLClassLoader.java:363)
	at java.security.AccessController.doPrivileged(Native Method)
	at java.net.URLClassLoader.findClass(URLClassLoader.java:362)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
	at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:349)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
	at sun.launcher.LauncherHelper.checkAndLoadMain(LauncherHelper.java:495)
Error: A JNI error has occurred, please check your installation and try again
Exception in thread "main"

沙箱安全机制

      自定义String类，但是在加载自定义String类的时候会率先使用引导类加载器加载，而引导类加载器在加载的过程中会先加载jdk自带的文件(rt.jar包中java\lang\String.class)，报错信息说没有main方法就是因为加载的是rt.jar包中的String类。这样可以保证对java核心源代码的保护，这就是沙箱安全机制。

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

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

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

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

      JVM必须知道一个类型是由启动加载器加载的还是由用户类加载器加载的。如果一个类型是由用户类加载器加载的，那么JVM会将这个类加载器的一个引用作为类型信息的一部分保存在方法区中。当解析一个类型到另一个类型的引用的时候，JVM需要保证这两个类型的类加载器是相同的。

类的主动使用和被动使用

Java程序对类的使用方式分为：主动使用和被动使用。

主动使用：又分为七种情况：

1、创建类的实例

2、访问某个类或接口的静态变量，或者对该静态变量赋值

3、调用类的静态方法

4、反射（比如：Class.forName("com.lwz.lwzTest")）

5、初始化一个类的子类

6、Java虚拟机启动时被标明为启动类的类

7、JDK7开始提供的动态语言支持：

java.lang.invoke.MethodHandle实例的解析结果

REF_getStatic、REF_putStatic、REF_invokeStatic句柄对应的类没有初始化，则初始化。

      除了以上七种情况，其他使用Java类的方式都被看作是对类的被动使用，都不会导致类的初始化。

JVM学习(一)

JVM学习(三)--运行时数据区


http://www.niftyadmin.cn/n/3298001.html

相关文章

程控制中关于搜索、控制计算机的功能 和 VB中截获shell程序的输出

程控制中关于搜索、控制计算机的功能 和 VB中截获shell程序的输出

相信大家对“冰河”之类的软件一定都非常的感兴趣&#xff0c;这里我们一起来讨论一下“冰河”类软件中关于如何实现搜索、控制远端计算机&#xff08;在局域网、或互联网上搜索那些中了木马的机器&#xff09;的功能。 一、 编程原理 客户端程序&#xff1a;&#xff08;控制远…
阅读更多...
JVM学习(三)--运行时数据区

JVM学习(三)--运行时数据区

目录 一、运行时数据区 1、简介 2、程序计数器(PC寄存器) 3、虚拟机栈 3.1、简介 3.2、栈的存储单位 3.3、局部变量表&#xff08;Local Variables&#xff09; 3.4、操作数栈&#xff08;Operand Stack&#xff09; 3.5、栈顶缓存&#xff08;Top-of-Stack Cashing&a…
阅读更多...
RenderMan介绍

RenderMan介绍

RenderMan介绍RenderMan是一种一流的渲染器或者说是一种渲染思想&#xff0c;一种系统。用于动画效果中的后毛发等制作的软件。这个软件是皮克斯开发的&#xff0c;广泛应用于好莱坞的影片&#xff0c;包括动画和真人电影中的特效镜头。 RenderMan是PIXAR出品的目前最强大的渲染…
阅读更多...
COBOL语言总结(三)--JCL扩展

COBOL语言总结(三)--JCL扩展

目录 一、JCL扩展 1、JCL语法规则&#xff1a; 2、JOB语句&#xff1a; 2.1、JOB语句中的位置参数 2.2、JOB语句中的关键字参数 3、EXEC语句 3.1、EXEC语句中的位置参数 3.2、EXEC语句中的关键字参数 3.3、COND参数 4、DD语句 4.1、DD语句中的位置参数 4.2、DD语句…
阅读更多...
SQL中N的作用

SQL中N的作用

declare sql nvarchar(4000)set sql Nselect TotalRecordscount(*) from N( sqlFullPopulate N) a EXEC sp_executesql sql,NTotalRecords int output, TotalRecords output 问题&#xff1a;sql 后面有个N, N 起什么作用? 答案&#xff1a; 加上 N 代表存入数据库时…
阅读更多...
jvm 初始化

jvm 初始化

package test;public class A {private static A a new A();private B b B.getInstance();private A() {}public static A getInstance() {System.out.println("A被调用");return a;}public void test() {System.out.println(b);}}package test;public class B {pr…
阅读更多...
Linux CentOS 7 系统配置IP地址新建用户

Linux CentOS 7 系统配置IP地址新建用户

目录 一、CentOS 7 系统配置IP地址 1、ifconfig 配置IP地址 2、修改配置文件配置IP地址 二、Linux创建用户 1、创建用户 三、wget命令安装 一、CentOS 7 系统配置IP地址 安装完CentOS 7后需要配置IP地址。 1、ifconfig 配置IP地址 该方法是临时配置IP地址&#xff0c;…
阅读更多...
URL字符串编码

URL字符串编码

Server.UrlEncode(s);Server.UrlDecode(s);转载于:https://www.cnblogs.com/ruanbl/archive/2008/12/05/1348189.html
阅读更多...
最新文章

Copyright @ 2022~2023