目录
一、类加载机制
1、类加载运行全过程
当我们运行程序使用到某个类时，类加载器会把该类加载到JVM
package com.cyy;
import com.cyy.pojo.User;
public class Math {
public static final int initData = 111;
public static User user = new User();
//一个方法对应一块栈帧内存区域
public int compute() {
int a = 1;
int b = 2;
int c = (a + b) * 10;
return c;
}
public static void main(String[] args) {
Math math = new Math();
math.compute();
}
}
以Windows系统下运行Math类为例，Java命令执行代码的大体流程如下
2、loadClass的类加载过程
1、加载：加载磁盘里的字节码文件，使用到类时才会加载
2、验证：验证字节码文件的正确性
3、准备：给类的静态变量分配内存，并赋予默认值，例如int初始值为0，boolean初始值为false，对象为null
4、解析：将符号引用转化为直接引用。该阶段会把一些静态方法(比如main()方法)替换为指向数据所存内存的指针或句柄等(直接引用)，即为静态链接过程(类加载期间完成)
符号引用：以一组符号来描述所引用的目标，包含在字节码文件的常量池中 ，它主要包括：在该类中出现过的各类包、类、接口、字段、方法等元素的全限定名
静态链接：当一个字节码文件被装载进 JVM 内部时，如果被调用的目标方法在编译期可知，且运行期保持不变时，这种情况下将调用方法的符号引用转换为直接引用的过程称之为静态链接
动态链接：如果被调用的方法在编译期无法被确定下来（例如多态），也就是说，只能够在程序运行期将调用的方法的符号转换为直接引用，由于这种引用转换过程具备动态性，因此也被称之为动态链接
执行命令：javap -v Math.class
Classfile /E:/projects/jvm/target/classes/com/cyy/Math.class
Last modified 2022-10-15; size 750 bytes
MD5 checksum 9a7408e7b50012ef060b9d3b33218543
Compiled from "Math.java"
public class com.cyy.Math
minor version: 0
major version: 52
flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
#1 = Methodref #8.#35 // java/lang/Object."<init>":()V
#2 = Class #36 // com/cyy/Math
#3 = Methodref #2.#35 // com/cyy/Math."<init>":()V
#4 = Methodref #2.#37 // com/cyy/Math.compute:()I
#5 = Class #38 // com/cyy/pojo/User
#6 = Methodref #5.#35 // com/cyy/pojo/User."<init>":()V
#7 = Fieldref #2.#39 // com/cyy/Math.user:Lcom/cyy/pojo/User;
#8 = Class #40 // java/lang/Object
#9 = Utf8 initData
#10 = Utf8 I
#11 = Utf8 ConstantValue
#12 = Integer 111
#13 = Utf8 user
#14 = Utf8 Lcom/cyy/pojo/User;
#15 = Utf8 <init>
#16 = Utf8 ()V
#17 = Utf8 Code
#18 = Utf8 LineNumberTable
#19 = Utf8 LocalVariableTable
#20 = Utf8 this
#21 = Utf8 Lcom/cyy/Math;
#22 = Utf8 compute
#23 = Utf8 ()I
#24 = Utf8 a
#25 = Utf8 b
#26 = Utf8 c
#27 = Utf8 main
#28 = Utf8 ([Ljava/lang/String;)V
#29 = Utf8 args
#30 = Utf8 [Ljava/lang/String;
#31 = Utf8 math
#32 = Utf8 <clinit>
#33 = Utf8 SourceFile
#34 = Utf8 Math.java
#35 = NameAndType #15:#16 // "<init>":()V
#36 = Utf8 com/cyy/Math
#37 = NameAndType #22:#23 // compute:()I
#38 = Utf8 com/cyy/pojo/User
#39 = NameAndType #13:#14 // user:Lcom/cyy/pojo/User;
#40 = Utf8 java/lang/Object
{
public static final int initData;
descriptor: I
flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL
ConstantValue: int 111
public static com.cyy.pojo.User user;
descriptor: Lcom/cyy/pojo/User;
flags: ACC_PUBLIC, ACC_STATIC
public com.cyy.Math();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
LineNumberTable:
line 5: 0
LocalVariableTable:
Start Length Slot Name Signature
0 5 0 this Lcom/cyy/Math;
public int compute();
descriptor: ()I
flags: ACC_PUBLIC
Code:
stack=2, locals=4, args_size=1
0: iconst_1
1: istore_1
2: iconst_2
3: istore_2
4: iload_1
5: iload_2
6: iadd
7: bipush 10
9: imul
10: istore_3
11: iload_3
12: ireturn
LineNumberTable:
line 12: 0
line 13: 2
line 14: 4
line 15: 11
LocalVariableTable:
Start Length Slot Name Signature
0 13 0 this Lcom/cyy/Math;
2 11 1 a I
4 9 2 b I
11 2 3 c I
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=2, args_size=1
0: new #2 // class com/cyy/Math
3: dup
4: invokespecial #3 // Method "<init>":()V
7: astore_1
8: aload_1
9: invokevirtual #4 // Method compute:()I
12: pop
13: return
LineNumberTable:
line 19: 0
line 20: 8
line 21: 13
LocalVariableTable:
Start Length Slot Name Signature
0 14 0 args [Ljava/lang/String;
8 6 1 math Lcom/cyy/Math;
static {};
descriptor: ()V
flags: ACC_STATIC
Code:
stack=2, locals=0, args_size=0
0: new #5 // class com/cyy/pojo/User
3: dup
4: invokespecial #6 // Method com/cyy/pojo/User."<init>":()V
7: putstatic #7 // Field user:Lcom/cyy/pojo/User;
10: return
LineNumberTable:
line 8: 0
}
SourceFile: "Math.java"
6、初始化：对类的静态变量初始化为指定的值，执行静态代码块
7、使用
8、卸载
类被加载到方法区中后主要包含：运行时常量池、类型信息、字段信息、方法信息、类加载器的引用、对应class实例的引用等信息。
注意：主类在运行过程中如果使用到其它类，会逐步加载这些类。
jar包或war包里的类不是一次性全部加载的，是使用到时才加载。
以下代码为例
package com.cyy;
public class TestLoad {
static {
System.out.println("======load TestLoad======");
}
public static void main(String[] args) {
new A();
System.out.println("======A已执行完======");
//B不会加载，除非这里执行 new B()
B b = null;
}
}
class A {
static {
System.out.println("======load A======");
}
public A() {
System.out.println("======init A======");
}
}
class B {
static {
System.out.println("======load B======");
}
public B() {
System.out.println("======init B======");
}
}
输出结果：
======load TestLoad======
======load A======
======init A======
======A已执行完======二、类加载器、双亲委派机制
1、类加载器
Java里有如下几种类加载器
- 引导类加载器(BootstrapLoader)：负责加载支撑JVM运行的位于JRE的lib目录下的核心类库，比如rt.jar、charsets.jar等
- 扩展类加载器(ExtClassLoader)：负责加载支撑JVM运行的位于JRE的lib目录下的ext扩展目录中的JAR类包
- 应用程序类加载器(AppClassLoader)：负责加载ClassPath路径下的类包，主要就是加载你自己写的那些类
- 自定义加载器：负责加载用户自定义路径下的类包
类加载器初始化过程：
创建JVM启动器实例sun.misc.Launcher。在Launcher构造方法内部，创建了两个类加载器，分别是sun.misc.Launcher.ExtClassLoader(扩展类加载器)和sun.misc.Launcher.AppClassLoader(应用类加载器)。JVM默认使用Launcher的getClassLoader()方法返回的类加载器AppClassLoader的实例加载我们的应用程序。
//Launcher的构造方法
public Launcher() {
Launcher.ExtClassLoader var1;
try {
//构造扩展类加载器，在构造的过程中将其父加载器设置为null
var1 = Launcher.ExtClassLoader.getExtClassLoader();
} catch (IOException var10) {
throw new InternalError("Could not create extension class loader", var10);
}
try {
//构造应用类加载器，在构造的过程中将其父加载器设置为ExtClassLoader，
//Launcher的loader属性值是AppClassLoader，我们一般都是用这个类加载器来加载我们自己写的应用程序
this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
} catch (IOException var9) {
throw new InternalError("Could not create application class loader", var9);
}
Thread.currentThread().setContextClassLoader(this.loader);
String var2 = System.getProperty("java.security.manager");
。。。 。。。 //省略一些不需关注代码
}2、双亲委派机制
双亲委派机制：当运行程序，使用到某个类时，会先在类所属的类加载器中查找是否有加载过此类，有加载过直接返回，若没被加载过，则会委托上级加载器寻找该类，有的话，就直接返回；找不到再委托上层加载器加载，如果所有上层加载器在自己的加载类路径下都找不到该类，则在自己的类加载路径中查找并载入该类
类加载器中loadClass方法的大体逻辑如下：
- 首先，检查一下该类是否已经加载过，如果加载过了，就不需要再加载，直接返回。
- 如果该类没有加载过，看是否有上层加载器；如果有上层加载器，则由上层加载器加载（即调用parent.loadClass(name, false);）.或者是调用bootstrap类加载器来加载。
- 如果上层加载器及bootstrap类加载器都没有找到指定的类，那么调用当前类加载器的findClass方法来完成类加载。
//ClassLoader的loadClass方法，里面实现了双亲委派机制
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
// 检查当前类加载器是否已经加载了该类
Class<?> c = findLoadedClass(name);
if (c == null) {
long t0 = System.nanoTime();
try {
if (parent != null) { //如果当前加载器父加载器不为空则委托父加载器加载该类
c = parent.loadClass(name, false);
} else { //如果当前加载器父加载器为空则委托引导类加载器加载该类
c = findBootstrapClassOrNull(name);
}
} catch (ClassNotFoundException e) {
// ClassNotFoundException thrown if class not found
// from the non-null parent class loader
}
if (c == null) {
// If still not found, then invoke findClass in order
// to find the class.
long t1 = System.nanoTime();
//都会调用URLClassLoader的findClass方法在加载器的类路径里查找并加载该类
c = findClass(name);
// this is the defining class loader; record the stats
sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
}
if (resolve) { //不会执行
resolveClass(c);
}
return c;
}
}为什么要设计双亲委派机制？
- 沙箱安全机制：自己写的java.lang.String.class类不会被加载，这样便可以防止核心API库被随意篡改
- 避免类的重复加载：当上层类加载器已经加载了该类，下层子加载器就不会再去加载，保证被加载类的唯一性
package java.lang;
public class String {
public static void main(String[] args) {
System.out.println("**************My String Class**************");
}
}
运行结果
运行结果：
错误: 在类 java.lang.String 中找不到 main 方法, 请将 main 方法定义为:
public static void main(String[] args)
否则 JavaFX 应用程序类必须扩展javafx.application.Application3、自定义类加载器
需要继承 java.lang.ClassLoader类
该类有两个核心方法：
loadClass(String, boolean)，实现了双亲委派机制，
findClass，默认实现是空方法，所以我们自定义类加载器主要是重写该方法。
package com.cyy;
import java.io.FileInputStream;
import java.lang.reflect.Method;
public class MyClassLoaderTest {
static class MyClassLoader extends ClassLoader {
private String classPath;
public MyClassLoader(String classPath) {
this.classPath = classPath;
}
private byte[] loadByte(String name) throws Exception {
name = name.replaceAll("\\.", "/");
FileInputStream fis = new FileInputStream(classPath + "/" + name + ".class");
int len = fis.available();
byte[] data = new byte[len];
fis.read(data);
fis.close();
return data;
}
protected Class<?> findClass(String name) throws ClassNotFoundException {
try {
byte[] data = loadByte(name);
//defineClass将一个字节数组转为Class对象，这个字节数组是class文件读取后最终的字节数组。
return defineClass(name, data, 0, data.length);
} catch (Exception e) {
e.printStackTrace();
throw new ClassNotFoundException();
}
}
}
public static void main(String args[]) throws Exception {
//初始化自定义类加载器，会先初始化父类ClassLoader，其中会把自定义类加载器的父加载器设置为应用程序类加载器AppClassLoader
MyClassLoader classLoader = new MyClassLoader("E:/test");
//D盘创建 test/com/tuling/jvm 几级目录，将User类的复制类User1.class丢入该目录
Class clazz = classLoader.loadClass("com.cyy.pojo.User1");
Object obj = clazz.newInstance();
Method method = clazz.getDeclaredMethod("sout", null);
method.invoke(obj, null);
System.out.println(clazz.getClassLoader().getClass().getName());
}
}运行结果：
=======自己的加载器加载类调用方法=======
com.cyy.MyClassLoaderTest$MyClassLoader以上程序中要确保项目中没有User1.class，这样才可以使用到自定义加载器加载该类
若是项目中含有User1.class则运行的结果：
=======自己的加载器加载类调用方法=======
sun.misc.Launcher$AppClassLoader4、打破双亲委派机制
以java的核心代码String为例，在程序中创建创建String类，编译后放入指定位置，再删除项目中的String.class
package com.cyy;
import java.io.FileInputStream;
import java.lang.reflect.Method;
public class MyClassLoaderTest1 {
static class MyClassLoader extends ClassLoader {
private String classPath;
public MyClassLoader(String classPath) {
this.classPath = classPath;
}
private byte[] loadByte(String name) throws Exception {
name = name.replaceAll("\\.", "/");
FileInputStream fis = new FileInputStream(classPath + "/" + name + ".class");
int len = fis.available();
byte[] data = new byte[len];
fis.read(data);
fis.close();
return data;
}
protected Class<?> findClass(String name) throws ClassNotFoundException {
try {
byte[] data = loadByte(name);
return defineClass(name, data, 0, data.length);
} catch (Exception e) {
e.printStackTrace();
throw new ClassNotFoundException();
}
}
/**
* 重写类加载方法，实现自己的加载逻辑，不委派给双亲加载
* @param name
* @param resolve
* @return
* @throws ClassNotFoundException
*/
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException {
synchronized (getClassLoadingLock(name)) {
// First, check if the class has already been loaded
Class<?> c = findLoadedClass(name);
if (c == null) {
// If still not found, then invoke findClass in order
// to find the class.
long t1 = System.nanoTime();
c = findClass(name);
// this is the defining class loader; record the stats
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
if (resolve) {
resolveClass(c);
}
return c;
}
}
}
public static void main(String args[]) throws Exception {
MyClassLoader classLoader = new MyClassLoader("E:/test");
//尝试用自己改写类加载机制去加载自己写的java.lang.String.class
Class clazz = classLoader.loadClass("java.lang.String");
Object obj = clazz.newInstance();
Method method= clazz.getDeclaredMethod("sout", null);
method.invoke(obj, null);
System.out.println(clazz.getClassLoader().getClass().getName());
}
}输出结果
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.lang.ClassLoader.defineClass(ClassLoader.java:642)
at com.cyy.MyClassLoaderTest1$MyClassLoader.findClass(MyClassLoaderTest1.java:28)
at com.cyy.MyClassLoaderTest1$MyClassLoader.loadClass(MyClassLoaderTest1.java:52)
at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
at com.cyy.MyClassLoaderTest1.main(MyClassLoaderTest1.java:69)5、Tomcat打破双亲委派机制
Tomcat是个web容器、需要解决以下几个问题：
1. 一个web容器可能需要部署两个应用程序，不同的应用程序可能会依赖同一个第三方类库的不同版本，不能要求同一个类库在同一个服务器只有一份，因此要保证每个应用程序的类库都是独立的，保证相互隔离。
2. 部署在同一个web容器中相同的类库相同的版本可以共享。否则，如果服务器有10个应用程序，那么要有10份相同的类库加载进虚拟机。
3. web容器也有自己依赖的类库，不能与应用程序的类库混淆。基于安全考虑，应该让容器的类库和程序的类库隔离开来。
4. web容器要支持jsp的修改，我们知道，jsp 文件最终也是要编译成class文件才能在虚拟机中运行，但程序运行后修改jsp已经是司空见惯的事情， web容器需要支持 jsp 修改后不用重启。
Tomcat 如果使用默认的双亲委派类加载机制就无法解决以上的问题：
第一个问题，如果使用默认的类加载器机制，那么是无法加载两个相同类库的不同版本的，默认的类加器是不管你是什么版本的，只在乎你的全限定类名，并且只有一份。
第二个问题，默认的类加载器是能够实现的，因为他的职责就是保证唯一性。
第三个问题和第一个问题一样。
第四个问题，jsp 文件其实也就是class文件，那么如果修改了，但类名还是一样，类加载器会直接取方法区中已经存在的，修改后的jsp是不会重新加载的。那么怎么办呢？我们可以直接卸载掉这jsp文件的类加载器，所以你应该想到了，每个jsp文件对应一个唯一的类加载器，当一个jsp文件修改了，就直接卸载这个jsp类加载器。重新创建类加载器，重新加载jsp文件。
tomcat 热加载其实就是一个线程去监听文件修改时间 ，会延迟1，2秒
tomcat的几个主要类加载器：
- CommonClassLoader：Tomcat最基本的类加载器，加载路径中的class可以被Tomcat容器本身以及各个Webapp访问；
- CatalinaLoader：Tomcat容器私有的类加载器，加载路径中的class对于Webapp不可见；
- SharedLoader：各个Webapp共享的类加载器，加载路径中的class对于所有Webapp可见，但是对于Tomcat容器不可见；
- WebappClassLoader：各个Webapp私有的类加载器，加载路径中的class只对当前Webapp可见，比如加载war包里相关的类，每个war包应用都有自己的WebappClassLoader，实现相互隔离，比如不同war包应用引入了不同的spring版本，这样实现就能加载各自的spring版本
tomcat的几个类加载器的委派关系：
- CommonClassLoader能加载的类都可以被CatalinaClassLoader和SharedClassLoader使用，从而实现了公有类库的共用，而CatalinaClassLoader和SharedClassLoader自己能加载的类则与对方相互隔离。
- WebAppClassLoader可以使用SharedClassLoader加载到的类，但各个WebAppClassLoader实例之间相互隔离。
- 而JsperLoader的加载范围仅仅是这个JSP文件所编译出来的那一个.Class文件，它出现的目的就是为了被丢弃：当Web容器检测到JSP文件被修改时，会替换掉目前的JsperLoader的实例，并通过再建立一个新的Jsp类加载器来实现JSP文件的热加载功能。
tomcat 这种类加载机没有遵循java 推荐的双亲委派模型，tomcat 为了实现隔离性，没有遵守这个约定，每个webappClassLoader加载自己的目录下的class文件，不会传递给父类加载器，打破了双亲委派机制。
当Jsp文件修改的时候，Tomcat更新步骤：
1、当访问某个jsp文件的时候，该jsp的包装类JspServletWrapper会去比较该jsp文件最新修改时间和上次的修改时间，以此判断该jsp是否修改过。
2、该jsp修改过的话，那么jspservletWrapper会清除相关引用，包括该jsp编译后的servlet实例和加载这个servlet的JasperLoader实例。
3、重新创建一个JasperLoader实例，重新加载修改过后的该jsp，重新生成一个Servlet实例。
4 、返回修改后的该jsp内容给用户。
模拟实现Tomcat的webappClassLoader加载自己war包应用内不同版本类实现相互共存与隔离
public class MyClassLoaderTest {
static class MyClassLoader extends ClassLoader {
private String classPath;
public MyClassLoader(String classPath) {
this.classPath = classPath;
}
private byte[] loadByte(String name) throws Exception {
name = name.replaceAll("\\.", "/");
FileInputStream fis = new FileInputStream(classPath + "/" + name
+ ".class");
int len = fis.available();
byte[] data = new byte[len];
fis.read(data);
fis.close();
return data;
}
protected Class<?> findClass(String name) throws ClassNotFoundException {
try {
byte[] data = loadByte(name);
return defineClass(name, data, 0, data.length);
} catch (Exception e) {
e.printStackTrace();
throw new ClassNotFoundException();
}
}
/**
* 重写类加载方法，实现自己的加载逻辑，不委派给双亲加载
* @param name
* @param resolve
* @return
* @throws ClassNotFoundException
*/
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException {
synchronized (getClassLoadingLock(name)) {
// First, check if the class has already been loaded
Class<?> c = findLoadedClass(name);
if (c == null) {
// If still not found, then invoke findClass in order
// to find the class.
long t1 = System.nanoTime();
//非自定义的类还是走双亲委派加载
if (!name.startsWith("com.tuling.jvm")){
c = this.getParent().loadClass(name);
}else{
c = findClass(name);
}
// this is the defining class loader; record the stats
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
if (resolve) {
resolveClass(c);
}
return c;
}
}
}
public static void main(String args[]) throws Exception {
MyClassLoader classLoader = new MyClassLoader("E:/test");
Class clazz = classLoader.loadClass("com.cyy.pojo.User1");
Object obj = clazz.newInstance();
Method method= clazz.getDeclaredMethod("sout", null);
method.invoke(obj, null);
System.out.println(clazz.getClassLoader());
System.out.println();
MyClassLoader classLoader1 = new MyClassLoader("E:/test1");
Class clazz1 = classLoader1.loadClass("com.cyy.pojo.User1");
Object obj1 = clazz1.newInstance();
Method method1= clazz1.getDeclaredMethod("sout", null);
method1.invoke(obj1, null);
System.out.println(clazz1.getClassLoader());
}
}运行结果
=======自己的加载器加载类调用方法=======
com.tuling.jvm.MyClassLoaderTest$MyClassLoader@266474c2
=======另外一个User1版本：自己的加载器加载类调用方法=======
com.tuling.jvm.MyClassLoaderTest$MyClassLoader@66d3c617注意：同一个JVM内，两个相同包名和类名的类对象可以共存，因为他们的类加载器可以不一样，所以看两个类对象是否是同一个，除了看类的包名和类名是否都相同之外，还需要他们的类加载器也是同一个才能认为他们是同一个。
扫一扫
9104
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
