文章目录
01、JVM与Java体系结构
虚拟机:
所谓虚拟机,就是一台虚拟的计算机。它是一款软件,用来执行一系列虚拟计算机指令。大体上,虚拟机可以分为系统虚拟机和程序虚拟机。
- 大名鼎鼎的Visual Box,VMware就属于系统虚拟机,它们完全是对物理计算机的仿真,提供了一个可运行完整操作系统的软件平台。
- 程序虚拟机的典型代表就是Java虚拟机,他专门为执行单个计算机程序而设计,在Java虚拟机中执行的指令我们称为Java字节码指令。
Java虚拟机:
- Java虚拟机是一台执行Java字节码的虚拟计算机,它拥有独立的运行机制,其运行的Java字节码也未必由Java语言编译而成。
- JVM平台的各种语言可以共享Java虚拟机带来的跨平台性,优越的垃圾回收器,以及可靠的即时编译器。
- Java技术的核心就是Java虚拟机,因为所有的Java程序都运行在Java虚拟机内部。
Java虚拟机作用:
Java虚拟机就是二进制字节码的运行环境,负责装载字节码到其内部,解释/编译为对应平台上的机器指令执行。每一条Java指令,Java虚拟机规范中都有详细定义,如怎么取操作数,怎么处理操作数,处理结果放在哪里。
特点:
- 一次编译,到处运行
- 自动内存管理
- 自动垃圾回收功能
JVM的位置
JVM是运行在操作系统之上的,它与硬件没有直接的交互。
JVM的整体结构:
它采用解释器与及时编译器并存的架构,
堆和方法区是在运行时数据区共享的
Java程序的执行流程
JVM的架构模型
Java编译器输入的指令流基本上是一种基于栈的指令集架构,另外一种指令集架构则是基于寄存器的指令集架构。
具体来说:这两种架构之间的区别:
- 基于栈式架构的特点:
- 设计和实现更简单,适用于资源受限的系统
- 避开了寄存器的分配难题:使用零地址指令方式分配
- 指令流中的指令大部分是零地址指令,其执行过程依赖于操作栈。指令集更小,编译器容易实现
- 不需要硬件支持,可移植性好,更好实现跨平台
- 基于寄存器架构的特点:
- 典型的应用是x86的二进制指令集,比如传统的PC以及Android的Davlik虚拟机
- 指令集架构则完全依赖硬件,可移植性差
- 性能优秀,执行更高效
- 基于寄存器架构的指令集往往都以一地址指令、二地址指令和三地址指令为主
总结:
由于跨平台性的设计,Java指令都是根据栈来设计的。不同平台CPU架构不同,所以不能设计为寄存器的。优点是跨平台性,指令集小,编译器容易实现,缺点是性能下降,实现同样的功能需要更多的指令(指令多)。
代码演示:
/**
* @Author: mei_ming
* @DateTime: 2022/10/15 22:35
* @Description: 查看栈指令集
*/
public class StockInstructionTest {
public static void main(String[] args) {
int i = 2;
int j = 3;
int k = i + j;
}
/**
* 对应指令 找到对应路径下,输入 javap -v StockInstructionTest.class 可显示下列内容
* public static void main(java.lang.String[]);
* descriptor: ([Ljava/lang/String;)V
* flags: ACC_PUBLIC, ACC_STATIC
* Code:
* stack=2, locals=4, args_size=1
* 0: iconst_2
* 1: istore_1
* 2: iconst_3
* 3: istore_2
* 4: iload_1
* 5: iload_2
* 6: iadd
* 7: istore_3
* 8: return
*/
}
JVM的生命周期
虚拟机的启动:
Java虚拟机的启动是通过引导类加载器(bootstrap class loader) 创建一个初始类(initial class)来完成的,这个类是由虚拟机的具体实现指定的。
虚拟机的执行:
- 一个运行中的Java虚拟机有着一个清晰的任务,执行Java程序。
- 程序开始执行时,他才运行,程序结束时,他就停止
- 执行一个所谓的Java程序的时候,真正在执行的是一个叫做Java虚拟机的进程
- 查看进程命令:
jps
虚拟机的退出:
有如下的几种情况:
- 程序正常执行结束
- 程序在执行过程中遇到了异常或错误而异常终止
- 由于操作系统出现错误而导致Java虚拟机进程终止
- 某线程调用Runtime类或System类的exit()方法,或Runtime类的halt()方法,并且Java安全管理器也允许这次exit或halt操作。
- 除此之外,JNI(Java Native Interface)规范描述了用JNI Invocation API来加载或卸载Java虚拟机时,Java虚拟机的退出情况
02、类加载子系统
简图:
详细图:
类加载器与类的加载过程
- 类加载器子系统负责从文件系统或者网络中加载Class文件,class文件在文件开头有特定的文件标识。
- ClassLoader 只负责class文件的加载,至于它是否可以运行,则由Execution Engine(执行引擎)决定
- 加载的类信息存放于一块称为方法区的内存空间。除了类的信息外,方法区中还会存放运行时常量池信息,可能还包括字符串字面量和数字常量(这部分常量信息是Class文件中常量池部分的内存映射)
类加载器ClassLoader角色
- class file 存在于本地硬盘上,可以理解为设计师画在纸上的模板,而最终这个模板在执行的时候是要加载到JVM当中来根据这个文件实例化出n个一模一样的实例。
- class file 加载到JVM中,被称为DNA元数据模板,放在方法区
- 在 .class 文件 -> JVM -> 最终成为元数据模板,此过程就要一个运输工具(类装载器,Class Loader),扮演一个快递员的角色
类的加载过程
加载:
- 通过一个类的全限定名获取定义此类的二进制字节流
- 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构
- 在内存中生成一个代表这个类的java.lang.Class对象。(反射)作为方法区这个类的各种数据的访问入口
补充:加载 .class 文件的方式
- 从本地系统中直接加载
- 通过网络获取,典型场景:Web Applet
- 从zip压缩包中读取,成为日后jar/war格式的基础
- 运行时计算生成,使用最多的是:动态代理技术
- 由其他文件生成,典型场景:JSP应用
- 从专有数据库中提取.class文件,比较少见
- 从加密文件中获取,典型的防Class文件被反编译的保护措施
链接:
-
验证(Verify):
- 目的在于确保Class文件的字符流中包含信息符合当前虚拟机要求,保证被加载类的正确性,不会危害虚拟机自身安全
- 主要包括四种验证:文件格式验证(开头都有CAFE BABE),元数据验证,字节码验证,符号引用验证。
-
准备(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>()
方法在多线程下被同步加锁。
代码如下:
验证:<clinit>()
由静态代码块和类变量赋值组成
验证:<init>()
是类构造器,内部至少有一个
验证:加载子类时要先加载父类
验证: 一个类只能加载一次
package com.ming.java;
/**
* @Author: mei_ming
* @DateTime: 2022/10/17 20:02
*/
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();
/**
* 运行结果:
* 线程2开始
* 线程1开始
* 线程2初始化当前类
*/
}
}
class DeadThread{
static{
if (true){
System.out.println(Thread.currentThread().getName()+"初始化当前类");
while(true){
}
}
}
}
类加载器的分类及其使用
JVM支持两种类型的类加载器,分别为引导类加载器(Bootstrap ClassLoader)和自定义类加载器(User-Defined ClassLoad).
从概念上来讲,自定义类加载器一般指的是程序中由开发人员自定义的一类类加载器,但是Java虚拟机规范却没有这么定义,而是将所有派生于抽象类ClassLoader的类加载器都划分为自定义类加载器。
无论类加载器的类型如何划分,在程序中我们最常见的类加载器始终只有3个,如下所示:
这里的四者之间的关系是包含关系。不是上层下层,也不是子夫类的继承关系
sun.misc.Luncher
它是一个java虚拟机的入口应用
测试代码:
package com.ming.java;
/**
* @Author: mei_ming
* @DateTime: 2022/10/18 20:41
*/
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@4554617c
//获取其上层,null
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 classLoader2 = String.class.getClassLoader();
System.out.println(classLoader2); // 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放在此目录下,也会自动由扩展类加载器加载
- Java语言编写,由
-
扩展类加载器(Extension ClassLoader)
- Java语言编写,由
sun.misc.Launcher$AppClassLoader
实现 - 派生于ClassLoader类
- 父类加载器为扩展类加载器
- 它负责加载环境变量classpath或系统属性
java.class.path
指定路径下的类库 - 该类加载是程序中默认的类加载器,一般来说,Java应用的类都是由它来完成加载
- 通过
ClassLoader#getSystemClassLoader()
方法可以获取到该类加载器
- Java语言编写,由
package com.ming.java;
import sun.misc.Launcher;
import sun.security.ec.CurveDB;
import java.net.URL;
import java.security.Provider;
/**
* @Author: mei_ming
* @DateTime: 2022/10/18 21:11
* @Description: 验证
*/
public class ClassLoaderTest2 {
public static void main(String[] args) {
System.out.println("---------启动类加载器------------");
// 获取BootstrapClassLoader能够加载的api的路径
URL[] urLs = Launcher.getBootstrapClassPath().getURLs();
for (URL ele : urLs){
System.out.println(ele.toExternalForm());
}
/**
* file:/C:/Program%20Files/Java/jdk1.8.0_181/jre/lib/resources.jar
* file:/C:/Program%20Files/Java/jdk1.8.0_181/jre/lib/rt.jar
* file:/C:/Program%20Files/Java/jdk1.8.0_181/jre/lib/sunrsasign.jar
* file:/C:/Program%20Files/Java/jdk1.8.0_181/jre/lib/jsse.jar
* file:/C:/Program%20Files/Java/jdk1.8.0_181/jre/lib/jce.jar
* file:/C:/Program%20Files/Java/jdk1.8.0_181/jre/lib/charsets.jar
* file:/C:/Program%20Files/Java/jdk1.8.0_181/jre/lib/jfr.jar
* file:/C:/Program%20Files/Java/jdk1.8.0_181/jre/classes
*/
//从上面的路径中随意选择一个类,看看他的类加载器是:引导类加载器
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);
}
/**
* C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext
* C:\WINDOWS\Sun\Java\lib\ext
*/
//从上面的路径中随意选择一个类,看看他的类加载器是:扩展类加载器
ClassLoader classLoader2 = CurveDB.class.getClassLoader();
System.out.println(classLoader2); // sun.misc.Launcher$ExtClassLoader@7ea987ac
}
}
- 用户自定义类加载器
- 在Java的日常应用程序开发中,类的加载几乎是由上述3种类加载器相互配合执行的,在必要时,我们还可以自定义类加载器,来制定类的加载方式。
- 为什么要自定义类:
- 隔离加载类
- 修改类加载的方式
- 扩展加载源
- 防止源码泄露
用户自定义类加载器实现步骤:
1.继承抽象类java.lang.ClassLoader
2.在JDK1.2之前,在自定义类加载器时需要继承ClassLoader类并重写loadClass()方法,在1.2之后,不需要重写loadClass(),建议把自定义的类加载逻辑卸载findClass()中
3.在编写自定义类加载器时,如果没有太过复杂的需求,可以直接继承URLClassLoader类,这样就可以避免写findClass()方法及其获取字节流的方式
package com.ming.java;
import java.io.FileNotFoundException;
/**
* @Author: mei_ming
* @DateTime: 2022/10/18 21:36
* @Description: 自定义用户类加载器
*/
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<?> aClass = Class.forName("One", true, customClassLoader);
Object o = aClass.newInstance();
System.out.println(o.getClass().getClassLoader());
}catch (Exception e){
e.printStackTrace();
}
}
}
关于ClassLoader:
ClassLoader类,它是一个抽象类,其后所有的类加载器都继承自ClassLoader(不包括启动类加载器)
获取ClassLoader的途径:
package com.ming.java;
/**
* @Author: mei_ming
* @DateTime: 2022/10/19 21:25
* @Description: 获取ClassLoader的途径
*/
public class ClassLoaderTest3 {
public static void main(String[] args) {
try {
//方式1,获取加载类的ClassLoader
ClassLoader classLoader = Class.forName("java.lang.String").getClassLoader();
System.out.println(classLoader); // null
//方式2:获取当前线程上下文的ClassLoader
ClassLoader classLoader1 = Thread.currentThread().getContextClassLoader();
System.out.println(classLoader1); // sun.misc.Launcher$AppClassLoader@18b4aac2
//方式3:获取系统的ClassLoader
ClassLoader classLoader2 = ClassLoader.getSystemClassLoader();
System.out.println(classLoader2); // sun.misc.Launcher$AppClassLoader@18b4aac2
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
双亲委派机制与沙箱安全机制
Java虚拟机对class文件采用的是按需加载的方式,也就是说当需要使用该类时,才会将它的class文件加载到内存生成class对象。而且加载某个类的class文件时,Java虚拟机采用的双亲委派模式,即把请求交由父类处理,它是一种任务委派模式。
自定义 String
package java.lang;
/**
* @Author: mei_ming
* @DateTime: 2022/10/19 21:50
* @Description: 自己造String
*/
public class String {
//在类加载过程的第三个阶段 初始化
static {
System.out.println("我是自定义String类的静态代码块");
}
public static void main(String[] args) {
System.out.println("你好");
/**
* 程序报错:
*
* 错误: 在类 java.lang.String 中找不到 main 方法, 请将 main 方法定义为:
* public static void main(String[] args)
* 否则 JavaFX 应用程序类必须扩展javafx.application.Application
*/
}
}
测试:
package com.ming.java2;
/**
* @Author: mei_ming
* @DateTime: 2022/10/19 21:49
* @Description: 双亲委派机制的案例
*/
public class StringTest {
public static void main(String[] args) {
String str = new String(); // 没有执行自定义的String类
System.out.println("hello,world");
}
}
由上可知,双亲委派机制的工作原理:
- 如果一个类加载器收到了类加载请求,它并不会自己先去加载,而是把这个请求委托给父类的加载器去执行;
- 如果父类加载器还存在其父类加载器,则进一步向上委托,依次递归,请求最终将到达顶层的启动类加载器;
- 如果父类加载器可以完成类加载任务,就成功返回,若父类加载器无法完成加载任务,子加载器才会尝试自己去加载,这就是双亲委派模式
反向委派:
优点:
- 避免类的重复加载
- 保护程序安全,防止核心API被随意篡改
- 自定义类:java.lang.String
- 自定义类:java.lang.NewString
package java.lang;
/**
* @Author: mei_ming
* @DateTime: 2022/10/19 22:14
*/
public class NewString {
public static void main(String[] args) {
System.out.println("hello");
/**
* 程序报错
*
* java.lang.SecurityException: Prohibited package name: java.lang
* 不能定义在java.lang包下
*/
}
}
沙箱安全机制:
自定义String类,但是在加载自定义String类的时候会率先使用引导类加载器加载,而引导类加载器在加载的过程中会加载jdk自带的文件(rt.jar包中java.lang.String.Class),报错信息没有main方法,就是因为加载的是rt.jar包中的String类。这样可以保证对java核心源代码的保护,这就是沙箱安全机制。
其他知识点:
在JVM中表示两个Class对象是否为同一个类存在两个必要条件:
- 类的完整类名必须一致,包括包名。
- 加载这个类的ClassLoader(指ClassLoader实例对象)必须相同。