一、什么是字节码指令，为什么要学习它？
了解字节码能够帮助我们更好的理解java程序的执行过程
答：JVM的指令由一个字节组成（256种指令），一般由一个操作码和0或多个操作数组成，jvm种也有许多指令只有操作码没有操作数
二、字节码笔试题
int i= 10;
i = i++;
sout(i) //10
---------------------------
int i=2;
i *= i++;
sout(i) //4
---------------------------
int k = 10;
k = k + (k++) + (++k);
sout(k) //32
---------------------------
包装类对象的缓存问题(所有整型包装类缓存了-128-127的数，)
Integer i1 = 10;
Integer i2 = 10;
i1 == i2 // true
Integer i3 = 128;
Integer i4 = 128;
i3==i4 //false
Boolean t1 = true;
Boolean t2 = true;
t1 == t2 //true
---------------------------
class Father{
int x = 10;
public Father() {
this.print();
x = 20;
}
public void print(){
sout("Father.x = " + x);
}
}
class Son extends Father{
int x = 30;
public Son(){
this.print();
x = 40;
}
public void print(){
sout("Son.x = " + x);
}
}
public static void main(){
Father f = new Son();
sout(f.x);
}
结果：
Son.x = 0
Son.x = 30
20
最后一题解析：
- new Son()首先会执行父类的init指令，具体如下：
1. 将Father.x赋值为10
2. 执行this.print() 注意：这个this指向的是Son，此时Son的x还没被赋值，为0，所以打印 Son.x=0
3. 将Father.x赋值为20 - 执行Son的init指令
- 将x赋值为30
- 执行this.print()，打印Son.x=30
- 将x赋值为40
- Father f = new Son()
1.Son构造完后，f会指向Son中属于Father的部分
2.Father.x在第一步中最后变为了20，索引打印 20s
三、class文件有几个部分？
- 魔数
- class版本
- 常量池
- 访问标志
- 类索引、父类索引、接口索引集合
- 字段表集合
- 方法表集合
- 属性表集合
四、字节码指令
- 加载、存储指令
- 算术指令
- 对象创建与访问指令
- 方法调用和返回指令
- 操作数栈管理指令
- 控制转移指令
- 异常处理指令
- 同步控制指令
五、类加载过程
loading–>linking–>using–>unloading
面试题
- 类的加载过程
- 描述一下JVM加载Class文件的原理机制
- JVM底层怎么加载class文件的
- Java类加载过程
- 描述一下JVM加载Class文件的原理机制
- 什么是类的加载
- Class.forName("Java.lang.String)和Class的getClassLoader()的loadClass("Java.lang.String)有什么区别
注意：涉及到原理机制的问题不但需要答加载过程，还需要答类加载器的知识点
一、loading
将class文件加载到方法区中生成类模板，并在堆中创建这个类的Class对象，该class对象的对象头指向方法区的类模板，该类所有实例对象都指向这个Class对象
二、linking
验证：
校验字节码文件是否能被正确执行，校验数据类型、符号引用是否正确。
准备：
为类的静态变量分配内存，并为那些基础类型赋默认值
注意：final修饰的static基本类型数据在编译的时候就已经赋值了
解析
将符号引用转化为直接引用，也就是得到类、字段、方法在内存中的指针或者偏移量。可以说，如果直接引用存在那么系统肯定存在该类、方法或字段，但只存在符号引用则不能确定是否存在
注意：解析往往在初始化之后再执行
初始化
初始化时类装载的最后一个阶段，此时，类才会开始执行字节码，它的重要工作是执行clinit方法来完成静态变量的显式赋值，clinit方法只有在类中存在显式赋值的静态变量时才会出现
public class InitializationTest{
public static int a = 1; //初始化阶段赋值
public static final int INT_CONSTANT = 10; //链接阶段赋值
public static int INT_CONSTANT1 = Integer.valueOf(100); //初始化阶段赋值
public static int INT_CONSTANT2 = Integer.valueOf(1000); //初始化阶段
public static final String s0 = "helloworld"; //链接
public static final String s1 = new String("helloworld"); //初始化
public class T { //T:使用系统类加载器加载。
public static int k = 0;
public static T t1 = new T("t1");
public static T t2 = new T("t2");
public static int i = print("i");
public static int n = 99;
static {
print("静态块");
}
public int j = print("j");
{
print("构造块");
}
public T(String str) {
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n);
++n;
++i;
}
public static int print(String str) {
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n);
++n;
return ++i;
}
public static void main(String[] args) {
}
}
注意：clinit方法带线程安全锁，可能会导致死锁问题
触发类加载的时机
Class只有在必须要首次使用的时候才会装载，jvm不会无条件的装载Class类型。jvm规定，一个类或接口在初次使用前必须执行初始化，这里的“使用”指的是主动使用
主动使用
- 创建类的实例，比如new、反射、克隆、反序列化
- 调用类的静态方法，也就是执行invokestatic指令
- 使用类、接口的静态字段，也就是getstatic和putstatic指令时候
- 调用Class.forName时
- 初始化子类时，若父类没有初始化，则会先触发父类初始化
- 若接口定义default方法，那么直接或间接实现该接口的类的初始化要在接口初始化之后
- jvm启动时，虚拟机会先初始化主类(包含main方法的类)
被动使用
1. 访问父类的静态字段不会导致子类初始化
2. 通过数组定义类引用，不会触发此类初始化
3. 引用常量不会触发类的初始化，因为常量在链接阶段已经赋值好
4. 调用ClassLoader的loadClass()方法加载一个类不会导致类的初始化
被动使用：意味着不需要执行初始化环节，没有()的调用
六、类加载器
将class文件以各种方式加载到jvm中，并生成一个与目标类对应的Class对象实例。然后交给jvm进行链接、初始化等操作
注意：ClassLoader在整个装载阶段只影响到类的加载
自定义加载器的使用场景：
- 通过类加载器实现绝妙的插件机制，比如OSGI组件框架
- 实现应用隔离，如tomcat、Spring等中间件框架都在内部实现了自定义的内加载器
- 实现类库的动态加载
源码分析
loadClass
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) {
long t0 = System.nanoTime();
try {
//parent若不为null说明其上级不是引导类，直接使用parent.loadClass
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
}
//如果c此时仍未被加载说明上级无法加载此类，由自身来处理
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.getParentDelegationTime().addTime(t1 - t0);
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
}
findClass
//由子类去实现类的查找方法
protected Class<?> findClass(String name) throws ClassNotFoundException {
throw new ClassNotFoundException(name);
}
defineClass
//将字节码文件转化为class对象，一般自定义ClassLoader中需要调用该方法
@Deprecated
protected final Class<?> defineClass(byte[] b, int off, int len)
throws ClassFormatError
{
return defineClass(null, b, off, len, null);
}
preDefineClass:确保java核心类由引导类加载器加载，而不是自定义类加载器
private ProtectionDomain preDefineClass(String name,
ProtectionDomain pd)
{
if (!checkName(name))
throw new NoClassDefFoundError("IllegalName: " + name);
// Note: Checking logic in java.lang.invoke.MemberName.checkForTypeAlias
// relies on the fact that spoofing is impossible if a class has a name
// of the form "java.*"
if ((name != null) && name.startsWith("java.")) {
throw new SecurityException
("Prohibited package name: " +
name.substring(0, name.lastIndexOf('.')));
}
if (pd == null) {
pd = defaultDomain;
}
if (name != null) checkCerts(name, pd.getCodeSource());
return pd;
}
自定义ClassLoader
public class UserClassLoader extends ClassLoader {
private String rootDir;
public UserClassLoader(String rootDir) {
this.rootDir = rootDir;
}
/**
* 编写findClass方法的逻辑
*/
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
// 获取类的class文件字节数组
byte[] classData = getClassData(name);
if (classData == null) {
throw new ClassNotFoundException();
} else {
//直接生成class对象
return defineClass(name, classData, 0, classData.length);
}
}
/**
* 编写获取class文件并转换为字节码流的逻辑 * @param className * @return
*/
private byte[] getClassData(String className) {
// 读取类文件的字节
String path = classNameToPath(className);
try {
InputStream ins = new FileInputStream(path);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int len = 0;
// 读取类文件的字节码
while ((len = ins.read(buffer)) != -1) {
baos.write(buffer, 0, len);
}
return baos.toByteArray();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
/**
* 类文件的完全路径
*/
private String classNameToPath(String className) {
return rootDir + "\\" + className.replace('.', '\\') + ".class";
}
public static void main(String[] args) {
String rootDir = "D:\\code\\workspace_teach\\JVMdachang210416\\chapter02_classload\\src\\";
try {
//创建自定义的类的加载器1
UserClassLoader loader1 = new UserClassLoader(rootDir);
Class clazz1 = loader1.findClass("com.atguigu.java3.User");
//创建自定义的类的加载器2
UserClassLoader loader2 = new UserClassLoader(rootDir);
Class clazz2 = loader2.findClass("com.atguigu.java3.User");
System.out.println(clazz1 == clazz2); //clazz1与clazz2对应了不同的类模板结构。
System.out.println(clazz1.getClassLoader());
System.out.println(clazz2.getClassLoader());
//######################
Class clazz3 = ClassLoader.getSystemClassLoader().loadClass("com.atguigu.java3.User");
System.out.println(clazz3.getClassLoader());
System.out.println(clazz1.getClassLoader().getParent());
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
双亲委派机制
在classLoader进行类加载的时候，首先会调用parent的loadClass方法，parent也会重复此步骤一直向上传递，直到遇到引导类加载器，如果整个向上传递的过程都没有classLoader能加载该类，则调用自己的findClass方法来找到该类并返回
优点：
1. 安全，防止核心api被篡改
2. 避免类的重复加载，确保一个
弊端
1. 上层类加载器无法调用下层类加载器去加载类
案例：
JDBC:sum公司定义了一个DriverManager接口，由bootstrap ClassLoader加载，但是具体实现由数据库各厂商完成，由于接口实现类由System ClassLoader完成，而DriverManager在启动类加载器中，故无法创建由系统类加载器加载的接口实现类，这时就需要打破双亲委派机制的方式来解决此问题，比如在DriverManager中获取系统类加载器，由系统类加载器来加载接口实现类。
面试题
- 双亲委派的好处有哪些
- 谈一谈双亲委派模型机制
- 双亲委派机制及使用原因
- 类加载器的双亲委派模型是什么
- 介绍一下双亲委派机制的优点
- 双亲委派机制可以打破吗？为什么？
Tomcat类加载器
1.1 WebAppClassLoader
首先来看第一个问题，假如我们使用JVM默认AppClassLoader来加载Web应用，AppClassLoader只能加载一个 Servlet 类，在加载第二个同名 Servlet 类时，AppClassLoader会返回第一个Servlet类的Class实例，这是因为在 AppClassLoader看来，同名的Servlet类只被加载一次。
因此Tomcat的解决方案是自定义一个类加载器WebAppClassLoader，并且给每个Web应用创建一个类加载器实例。我们知道，Context容器组件对应一个Web应用，因此，每个Context容器负责创建和维护一个WebAppClassLoader加载器实例，这背后的原理是，不同的加载器实例加载的类被认为是不同的类，即使它们的类名相同。这就相当于在Java虚拟机内部创建了一个个相互隔离的Java类空间，每一个Web应用都有自己的类空间，Web应用之间通过各自的类加载器互相隔离。
1.2 SharedClassLoader
再来看第二个问题，本质需求是两个Web应用之间怎么共享库类，并且不能重复加载相同的类。我们知道，在双亲委托机制里，各个子加载器都可以通过父加载器去加载类，那么把需要共享的类放到父加载器的加载路径下应该就可以了，应用程序也正是通过这种方式共享JRE的核心类。因此Tomcat的设计者又加了一个类加载器SharedClassLoader，作为WebAppClassLoader的父加载器，专门来加载Web应用之间共享的类。如果WebAppClassLoader自己没有加载到某个类，就会委托父加载器SharedClassLoader去加载这个类，SharedClassLoader会在指定目录下加载共享类，之后返回给WebAppClassLoader，这样共享的问题就解决了。
1.3 CatalinaClassloader
第三个问题，如何隔离Tomcat本身的类和Web应用的类。我们知道，要共享可以通过父子关系，要隔离那就需要兄弟关系了。兄弟关系就是指两个类加载器是平行的，它们可能拥有同一个父加载器,但是两个兄弟类加载器加载的类是隔离的。基于此Tomcat又设计一个类加载器CatalinaClassloader，专门来加载Tomcat自身的类。
如果Tomcat和各Web应用之间需要共享一些类时该怎么办？
1.4 CommonClassLoader
老办法，还是再增加一个CommonClassLoader，作为CatalinaClassloader和SharedClassLoader的父加载器。CommonClassLoader能加载的类都可以CatalinaClassLoader和SharedClassLoader使用，而CatalinaClassLoader和 SharedClassLoader能加载的类则与对方相互隔离。WebAppClassLoader可以使用SharedClassLoader加载到的类，但各个WebAppClassLoader实例之间相互隔离。
1.5 线程类加载器
在JVM的实现中有一条隐含的规则，默认情况下，如果一个类由类加载器A加载，那么这个类的依赖类也是由相同的类加载器加载。比如 Spring 作为一个Bean工厂，它需要创建业务类的实例，并且在创建业务类实例之前需要加载这些类。Spring是通过调用Class.forName来加载业务类的，我们来看一下forName的源码
public static Class<?> forName(String className)
throws ClassNotFoundException {
Class<?> caller = Reflection.getCallerClass();
return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
}
当应用需要用到某个类时，按照如下顺序加载：
- 使用引导类加载器加载
- 使用系统类加载器加载
- 使用webAppClassLoader加载WEB-INF/classes中的字节码文件
- 使用webAppClassLoader加载WEB-INF/lib中的字节码文件
- 使用common类加载器加载CATALINA_HOME/lib下的字节码文件
面试题
- 既然tomcat不遵循双亲委派机制？那么自己定义一个恶意的hashmap，会不会由风险？
答：不会，tomcat只是自定义的类加载器不遵循双亲委派机制，但是顶层还是相同的，核心类库还是由引导类加载器来加载 - Tomcat作为一个web容器，它需要解决什么问题？
答：共享和隔离问题，多个webapp可能依赖同一个第三方库但版本不同，需要通过不同的webapp类加载器来实现隔离，同时，同一个依赖的相同版本应该可以是共享的
7518
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
