待补充
假设我们想自己手写一个Java虚拟机的话,必须考虑哪些结构
类加载器子系统负责从文件系统或者网络中加载Class文件
,class文件在文件开头有特定的文件标识。加载的类信息存放于一块称为方法区的内存空间
。除了类的信息外,方法区中还会存放运行时常量池信息,可能还包括字符串字面量和数字常量(这部分常量信息是Class文件中常量池部分的内存映射)类加载器子系统负责从文件系统或者网络中加载Class文件,class文件在文件开头有特定的文件标识。
ClassLoader只负责.class文件的加载
,至于它是否可以运行,则由Execution Engine
决定。
加载的类信息存放于一块称为方法区的内存空间。除了类的信息外,方法区中还会存放运行时常量池信息,可能还包括字符串字面量和数字常量(这部分常量信息是Class文件中常量池部分的内存映射)
面试题:Java8中的JVM元空间是不是方法区?
严格来说,不是。
- 首先,方法区是JVM规范的一个概念定义,并不是一个具体的实现,每一个JVM的实现都可以有各自的实现;
- 然后,在Java官方的HotSpot 虚拟机中,Java8版本以后,是用元空间来实现的方法区;在Java8之前的版本,则是用永久代实现的方法区;
- 也就是说,“元空间” 和 “方法区”,一个是HotSpot 的具体实现技术,一个是JVM规范的抽象定义;
所以,并不能说“JVM的元空间是方法区”,但是可以说在Java8以后的HotSpot 中“元空间用来实现了方法区”。
然后多说一句,
这个元空间是使用本地内存(Native Memory)实现的,也就是说它的内存是不在虚拟机内的,所以可以理论上物理机器还有多个内存就可以分配,而不用再受限于JVM本身分配的内存了
。参考:http://openjdk.java.net/jeps/122作者:Butters
链接:https://www.zhihu.com/question/358312524/answer/965401488
来源:知乎
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
DNA元数据模板
,放在方法区。.class文件
–> JVM –> 最终成为元数据模板,此过程就要一个运输工具(类装载器Class Loader),扮演一个快递员的角色。/**
* @author xiexu
* @create 2020-11-18 11:57 上午
*/
public class HelloLoader {
public static void main(String[] args) {
System.out.println("谢谢ClassLoader加载我....");
System.out.println("你的大恩大德,我下辈子再报!");
}
}
它的加载过程是怎么样的呢?
加载 --> 链接(验证 --> 准备 --> 解析) --> 初始化 -->使用 --> 卸载
注意:此处的类加载指的是一个.class文件的加载,在Java中.class文件可能是一个类,也可能是一个接口。此处都叫做类加载。整个类加载的过程即:加载→验证→准备→解析→初始化。概括地说即:
这里需要注意:从类的加载→验证→准备→初始化,过程是按顺序依次开始的,但是解析比较特殊。为了支持java语言的晚期绑定/动态绑定,有时解析可以在初始化之后才开始。
而且,这里写的是开始顺序,(不代表是按照这个顺序依次进行或者依次完成)一个阶段通常执行的过程中会激活调用另一个阶段,所以各个阶段只是按照这个顺序开始,而不会等一个阶段完全完成后才进行下一个阶段,各个阶段是交叉混合进行的,所以各阶段并不会严格按照此顺序结束。
通过一个类的全限定名获取定义此类的二进制字节流
将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构
在内存中生成一个代表此类的java.lang.Class对象
</,作为方法区这个类的各种数据的访问入口
某个类的java.lang.Class对象,即通常所说的一个类的类对象,这个类对象作为程序调用这个类中方法和数据调用的入口。
加载阶段完成后,虚拟机外部的二进制字节流就按照虚拟机所需的格式存储在方法区之中,方法区中的数据存储格式是由虚拟机是实现自行定义的
? 最常见的一种情况是将已存在的类的Class文件(也就是字节码文件)从磁盘上面加载到内存里面,将其放在运行时数据区的方法区中,然后在内存中创建一个java.lang.Class对象用来封装类在方法区中的数据结构
.class文件
的方式动态代理技术
我们需要注意的是:
对于方法区的认识:被加载的类的信息存储在方法区中,可以被线程所共享
,也就是说,加载阶段完成后,虚拟机外部的二进制字节流就按照虚拟机所需的格式存储在了方法区之中。
然后你能想起来那个二进制流中都存储了哪些信息吗?
对于Class对象认识:Class对象虽然是在内存中,但并未明确规定是在Java堆中,对于HotSpot来说,Class对象存储在方法区中font>。它作为程序访问方法区中二进制字节流中所存储各种数据的接口。你能大概想到反射机制中的Class对象是怎么一回事了吗?为什么可以在运行期通过反射机制得到那么多的类信息你能猜测到吗?
类对象生成的方式:
? https://link.zhihu.com/?target=https%3A//blog.csdn.net/justloveyou_/article/details/72466416)
1). 使用new关键字创建对象
2). 使用Class类的newInstance方法(反射机制)
3). 使用Constructor类的newInstance方法(反射机制)
4). 使用Clone方法创建对象
5). 使用(反)序列化机制创建对象。
相对于类加载过程 的其他阶段:
一个 非数组类
的加载阶段 (准确来说,是加载阶段中获取类的二进制字节流的动作) 是开发人员可控性最强的
因为加载阶段既可以使用系统提供的类加载器来完成,也可以由通过用户自定义的类加载器来完成,
开发人员可以通过定义一个自己的类加载器从而控制字节流的获取方式(即重写一个类加载器的loadClass()方法)
链接分为三个子阶段:
验证 --> 准备 --> 解析
目的在于确保Class文件的字节流中包含信息符合当前虚拟机要求,保证被加载类的正确性,不会危害虚拟机自身安全
主要包括四种验证,文件格式验证,元数据验证,字节码验证,符号引用验证。
使用 BinaryViewer 查看字节码文件,其开头均为 CAFE BABE ,如果出现不合法的字节码文件,那么将会验证不通过
默认初始值
,即零值
这里不包含用final修饰的static,因为final在编译的时候就会分配好了默认值,准备阶段会显式初始化
这里不会为实例变量分配初始化
,类变量会分配在方法区中,而实例变量是会随着对象一起分配到Java堆中举例:
变量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);
}
}
符号引用
初始化阶段就是执行类构造器方法
此方法不需定义,是javac编译器自动收集类中的所有类变量的赋值动作和静态代码块中的语句合并而来。也就是说,当我们代码中包含static变量的时候,就会有
若该类具有父类,JVM会保证子类的
虚拟机必须保证一个类的
IDEA安装 JClassLib 插件
当我们代码中包含static变量的时候,就会有clinit方法
/**
* @author xiexu
* @create 2020-11-20 8:50 上午
*/
public class ClassInitTest {
private static int num = 1;
static {
num = 3;
}
public static void main(String[] args) {
System.out.println(ClassInitTest.num);
}
}
如果当前类不存在static变量,那么它的字节码文件是不会存在
public class ClinitTest {
private int a = 1;
public static void main(String[] args) {
int b = 2;
}
}
/**
* @author xiexu
* @create 2020-11-20 8:50 上午
*/
public class ClassInitTest {
private static int num = 1;
static {
num = 3;
number = 20;
System.out.println(num);
//System.out.println(number); //报错:非法的前向引用(可以赋值,但不能调用)
}
//linking之prepare:number = 0 --> initial:20 --> 10
private static int number = 10;
public static void main(String[] args) {
System.out.println(ClassInitTest.num); //3
System.out.println(ClassInitTest.number); //10
}
}
静态变量 number 的值变化过程如下
public class ClinitTest {
//任何一个类声明以后,内部至少存在一个类的构造器
private int a = 1;
private static int c = 3;
public static void main(String[] args) {
int b = 2;
}
public ClinitTest(){
a = 10;
int d = 20;
}
}
在构造器中:
先将类变量 a 赋值为 10
再将局部变量赋值为 20
若该类具有父类,JVM会保证子类的
()执行前,父类的 ()已经执行完毕
public class ClinitTest1 {
static class Father{
public static int A = 1;
static{
A = 2;
}
}
static class Son extends Father{
public static int B = A;
}
public static void main(String[] args) {
//加载Father类,其次加载Son类。
System.out.println(Son.B); //2
}
}
如上代码,加载流程如下:
虚拟机必须保证一个类的
()方法在多线程下被同步加锁
public class DeadThreadTest {
public static void main(String[] args) {
Runnable r = () -> {
System.out.println(Thread.currentThread().getName() + "开始");
DeadThread dead = new DeadThread();
System.out.println(Thread.currentThread().getName() + "结束");
};
Thread t1 = new Thread(r, "线程1");
Thread t2 = new Thread(r, "线程2");
t1.start();
t2.start();
}
}
class DeadThread {
static {
if (true) {
System.out.println(Thread.currentThread().getName() + "初始化当前类");
while (true) {
}
}
}
}
程序卡死,分析原因:
JVM支持两种类型的类加载器 。分别为引导类加载器(Bootstrap ClassLoader)
和自定义类加载器(User-Defined ClassLoader)
从概念上来讲,自定义类加载器一般指的是程序中由开发人员自定义的一类类加载器,但是Java虚拟机规范却没有这么定义,而是将所有派生于抽象类ClassLoader的类加载器都划分为自定义类加载器
无论类加载器的类型如何划分,在程序中我们最常见的类加载器始终只有3个,如下所示
为什么 ExtClassLoader 和 AppClassLoader 都属于自定义加载器
规范定义:所有派生于抽象类ClassLoader的类加载器都划分为自定义类加载器
ExtClassLoader 继承树
AppClassLoader 继承树
/**
* 注意:getParent() 只是获取上层的加载器,并不是继承关系
* @author xiexu
* @create 2020-11-20 10:49 上午
*/
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@61bbe9ba
//获取其上层:获取不到引导类加载器
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 ,这说明系统类加载器是全局唯一的
启动类加载器( 引导类加载器,Bootstrap ClassLoader )
C/C++
语言实现的,嵌套在JVM内部JAVA_HOME / jre / lib / rt.jar、resources.jar 或 sun.boot.class.path 路径下的内容
),用于提供JVM自身需要的类没有父加载器
j<font color=‘red‘>ava、javax、sun</font>
等开头的类扩展类加载器(Extension ClassLoader)
Java语言编写,由sun.misc.Launcher$ExtClassLoader实现
派生于ClassLoader类
父类加载器为启动类加载器从
java.ext.dirs
系统属性所指定的目录中加载类库,或从JDK的安装目录的 jre / lib / ext子目录(扩展目录)下加载类库。如果用户创建的 JAR 放在此目录下,也会自动由扩展类加载器加载
应用程序类加载器(系统类加载器,AppClassLoader)
classpath
或
系统属性java.class.path
指定路径下的类库
classLoader.getSystemclassLoader( )
方法可以获取到该类加载器
代码说明
public class ClassLoaderTest1 { public static void main(String[] args) { System.out.println("//////////启动类加载器//////////////"); //获取BootstrapClassLoader能够加载的api的路径 URL[] urLs = sun.misc.Launcher.getBootstrapClassPath().getURLs(); for (URL element : urLs) { System.out.println(element.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 classLoader1 = CurveDB.class.getClassLoader(); System.out.println(classLoader1);//sun.misc.Launcher$ExtClassLoader@1540e19d } }
System.out.println(classLoader); //null 再次证明我们无法获取到启动类加载器
//////////启动类加载器////////////// file:/Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home/jre/lib/resources.jar file:/Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home/jre/lib/rt.jar file:/Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home/jre/lib/sunrsasign.jar file:/Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home/jre/lib/jsse.jar file:/Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home/jre/lib/jce.jar file:/Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home/jre/lib/charsets.jar file:/Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home/jre/lib/jfr.jar file:/Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home/jre/classes null ///////////扩展类加载器///////////// /Users/xiexu/Library/Java/Extensions:/Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home/jre/lib/ext:/Library/Java/Extensions:/Network/Library/Java/Extensions:/System/Library/Java/Extensions:/usr/lib/java sun.misc.Launcher$ExtClassLoader@d716361
加载器的执行流程图
为什么需要自定义类加载器?
在Java的日常应用程序开发中,类的加载几乎是由上述3种类加载器相互配合执行的,在必要时,我们还可以自定义类加载器,来定制类的加载方式。
那为什么还需要自定义类加载器?
隔离加载类
修改类加载的方式
扩展加载源
防止源码泄露
如何自定义类加载器?
开发人员可以通过
继承抽象类java.lang.ClassLoader类
的方式,实现自己的类加载器,以满足一些特殊的需求
不再建议
用户去覆盖loadClass( )方法,而是
建议
把自定义的类
加载逻辑写在findclass( )方法中
直接继承URIClassLoader类
,这样就可以避免自己去编写findclass( )方法及其获取字节码流的方式,使自定义类加载器编写更加简洁。
代码举例:
public class CustomClassLoader extends ClassLoader { @Override protected Class findClass(String name) throws ClassNotFoundException { try { byte[] result = getClassFromCustomPath(name); if (result == null) { throw new FileNotFoundException(); } else { return defineClass(name, result, 0, result.length); } } catch (FileNotFoundException e) { e.printStackTrace(); } 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(
不包括启动类加载器
)
方法名称 描述 getParent( ) 返回该类加载器的超类加载器 loadClass(String name) 加载名称为name的类,返回结果为java.lang.Class类的实例 findClass(String name) 查找名称为name的类,返回结果为java.lang.Class类的实例 findLoadedClass(String name) 查找名称为name的已经被加载过的类,返回结果为java.lang.Class类的实例 defineClass(String name,byte[ ] b,int len) 把字节数组b中的内容转换为一个Java类,返回结果为java.lang.Class类的实例 resolveClass(Class<?> c) 连接指定的一个Java类
public class ClassLoaderTest2 { public static void main(String[] args) { try { //1.Class.forName().getClassLoader() ClassLoader classLoader = Class.forName("java.lang.String").getClassLoader(); System.out.println(classLoader); // String 类由启动类加载器加载,我们无法获取 //2.Thread.currentThread().getContextClassLoader() ClassLoader classLoader1 = Thread.currentThread().getContextClassLoader(); System.out.println(classLoader1); //sun.misc.Launcher$AppClassLoader@18b4aac2 //3.ClassLoader.getSystemClassLoader().getParent() ClassLoader classLoader2 = ClassLoader.getSystemClassLoader().getParent(); System.out.println(classLoader2); //sun.misc.Launcher$ExtClassLoader@61bbe9ba } catch (ClassNotFoundException e) { e.printStackTrace(); } } }
按需加载
的方式,也就是说当需要使用该类时才会将它的 class 文件加载到内存中生成 class 对象。而且加载某个类的class文件时,Java虚拟机采用的是
双亲委派模式
,即把请求交由父类处理,它是一种任务委派模式
委托给父类的加载器
去执行;
顶层的启动类加载器
;
举例一:
我们自己定义一个java.lang包,在其下面定义一个String类,里面声明了静态代码块
package java.lang; /// /* @author xiexu /* @create 2020-11-20 2:47 下午 /*/ public class String { static { System.out.println("我是自定义的String类的静态代码块"); } }
在一个测试类中加载String类,看看加载的String类是JDK自带的,还是我们自己编写的
/// /* @author xiexu /* @create 2020-11-20 2:44 下午 /*/ public class StringTest { public static void main(String[] args) { String str = new java.lang.String(); System.out.println("你好,世界"); } }
结果:程序并没有输出我们静态代码块中的内容,可见仍然加载的是 JDK 自带的 String 类
举例二:
在我们自己定义的 String 类中整个 main( ) 方法
public class String { static { System.out.println("我是自定义的String类的静态代码块"); } //错误: 在类 java.lang.String 中找不到 main 方法 public static void main(String[] args) { System.out.println("hello,String"); } }
原因:由于双亲委派机制,我们的String类是由引导类加载器加载的,而引导类加载器并没有main方法,所以会报错
举例三:
SPI接口是由引导类加载器加载的,接口具体的实现类是由线程上下文类加载器加载的,而线程上下文类加载器就是系统类加载器,所以我们在加载的时候,会先进行双亲委派,在引导类加载器加载SPI核心类,然后加载SPI接口,最后在反向委托,通过系统类加载器进行实现类 jdbc.jar 的加载
举例四:
package java.lang; /// /* @author xiexu /* @create 2020-11-20 3:25 下午 /*/ public class ShkStart { public static void main(String[] args) { System.out.println("hello!"); } }
出于保护机制,java.lang 包下不允许我们自定义类
避免类的重复加载
保护程序安全,防止核心API被随意篡改
自定义类:java.lang.String 没有调用
自定义类:java.lang.ShkStart(报错:阻止创建 java.lang开头的类)
沙箱安全机制
。
如何判断两个class对象是否相同?
在JVM中表示两个class对象是否为同一个类存在两个必要条件:
类的完整类名必须一致,包括
包名
加载这个类的 ClassLoader(指ClassLoader实例对象)必须相同
换句话说,在JVM中,即使这两个类对象(class对象)来源同一个Class文件,被同一个虚拟机所加载,但只要加载它们的 ClassLoader 实例对象不同,那么这两个类对象也是不相等的
对类加载器的引用
JVM必须知道一个类型是由启动加载器加载的还是由用户类加载器加载的
如果一个类型是由用户类加载器加载的,那么
JVM会将这个类加载器的一个引用作为类型信息的一部分保存在方法区中
Java程序对类的使用方式分为:
主动使用
和
被动使用
。
主动使用,又分为七种情况:
创建类的实例
访问某个类或接口的静态变量,或者对该静态变量赋值
调用类的静态方法
反射( 比如:Class.forName(“cn.sxt.Test”) )
初始化一个类的子类
Java虚拟机启动时被标明为启动类的类
JDK7开始提供的动态语言支持:java.lang.invoke.MethodHandle实例的解析结果REF_getStatic、REF putStatic、REF_invokeStatic句柄对应的类没有初始化,则初始化
除了以上七种情况,其他使用Java类的方式都被看作是对类的
被动使用
,
都不会导致类的初始化,即不会执行初始化阶段(不会调用 clinit( ) 方法和 init( ) 方法)
————————————————
版权声明:本文为CSDN博主「JavaAlenboy」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/sj15814963053/article/details/109851454
原文:https://www.cnblogs.com/tangliMeiMei/p/15168785.html