01-JVM-类加载篇

一、什么是字节码指令，为什么要学习它？

了解字节码能够帮助我们更好的理解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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

最后一题解析：

1. new Son()首先会执行父类的init指令，具体如下：
   1. 将Father.x赋值为10
   2. 执行this.print() 注意：这个this指向的是Son，此时Son的x还没被赋值，为0，所以打印 Son.x=0
   3. 将Father.x赋值为20
2. 执行Son的init指令
   1. 将x赋值为30
   2. 执行this.print()，打印Son.x=30
   3. 将x赋值为40
3. Father f = new Son()
   1.Son构造完后，f会指向Son中属于Father的部分
   2.Father.x在第一步中最后变为了20，索引打印 20s

三、class文件有几个部分？

• 魔数
• class版本
• 常量池
• 访问标志
• 类索引、父类索引、接口索引集合
• 字段表集合
• 方法表集合
• 属性表集合

四、字节码指令

1. 加载、存储指令
2. 算术指令
3. 对象创建与访问指令
4. 方法调用和返回指令
5. 操作数栈管理指令
6. 控制转移指令
7. 异常处理指令
8. 同步控制指令

五、类加载过程

loading–>linking–>using–>unloading

面试题

1. 类的加载过程
2. 描述一下JVM加载Class文件的原理机制
3. JVM底层怎么加载class文件的
4. Java类加载过程
5. 描述一下JVM加载Class文件的原理机制
6. 什么是类的加载
7. 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");  //初始化
1
2
3
4
5
6
7
8
9

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) {
        
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

注意：clinit方法带线程安全锁，可能会导致死锁问题

触发类加载的时机

Class只有在必须要首次使用的时候才会装载，jvm不会无条件的装载Class类型。jvm规定，一个类或接口在初次使用前必须执行初始化，这里的“使用”指的是主动使用

主动使用

1. 创建类的实例，比如new、反射、克隆、反序列化
2. 调用类的静态方法，也就是执行invokestatic指令
3. 使用类、接口的静态字段，也就是getstatic和putstatic指令时候
4. 调用Class.forName时
5. 初始化子类时，若父类没有初始化，则会先触发父类初始化
6. 若接口定义default方法，那么直接或间接实现该接口的类的初始化要在接口初始化之后
7. jvm启动时，虚拟机会先初始化主类(包含main方法的类)

被动使用
1. 访问父类的静态字段不会导致子类初始化
2. 通过数组定义类引用，不会触发此类初始化
3. 引用常量不会触发类的初始化，因为常量在链接阶段已经赋值好
4. 调用ClassLoader的loadClass()方法加载一个类不会导致类的初始化
被动使用：意味着不需要执行初始化环节，没有()的调用

六、类加载器

将class文件以各种方式加载到jvm中，并生成一个与目标类对应的Class对象实例。然后交给jvm进行链接、初始化等操作
注意：ClassLoader在整个装载阶段只影响到类的加载

自定义加载器的使用场景：

1. 通过类加载器实现绝妙的插件机制，比如OSGI组件框架
2. 实现应用隔离，如tomcat、Spring等中间件框架都在内部实现了自定义的内加载器
3. 实现类库的动态加载

源码分析

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;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

findClass

//由子类去实现类的查找方法
protected Class findClass(String name) throws ClassNotFoundException {
        throw new ClassNotFoundException(name);
    }
1
2
3
4

defineClass

//将字节码文件转化为class对象，一般自定义ClassLoader中需要调用该方法
@Deprecated
    protected final Class defineClass(byte[] b, int off, int len)
        throws ClassFormatError
    {
        return defineClass(null, b, off, len, null);
    }
1
2
3
4
5
6
7

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;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

自定义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();
        }


    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

双亲委派机制

在classLoader进行类加载的时候，首先会调用parent的loadClass方法，parent也会重复此步骤一直向上传递，直到遇到引导类加载器，如果整个向上传递的过程都没有classLoader能加载该类，则调用自己的findClass方法来找到该类并返回

优点：
1. 安全，防止核心api被篡改
2. 避免类的重复加载，确保一个
弊端
1. 上层类加载器无法调用下层类加载器去加载类
案例：
JDBC:sum公司定义了一个DriverManager接口，由bootstrap ClassLoader加载，但是具体实现由数据库各厂商完成，由于接口实现类由System ClassLoader完成，而DriverManager在启动类加载器中，故无法创建由系统类加载器加载的接口实现类，这时就需要打破双亲委派机制的方式来解决此问题，比如在DriverManager中获取系统类加载器，由系统类加载器来加载接口实现类。

面试题

1. 双亲委派的好处有哪些
2. 谈一谈双亲委派模型机制
3. 双亲委派机制及使用原因
4. 类加载器的双亲委派模型是什么
5. 介绍一下双亲委派机制的优点
6. 双亲委派机制可以打破吗？为什么？

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);
}
1
2
3
4
5

当应用需要用到某个类时，按照如下顺序加载：

1. 使用引导类加载器加载
2. 使用系统类加载器加载
3. 使用webAppClassLoader加载WEB-INF/classes中的字节码文件
4. 使用webAppClassLoader加载WEB-INF/lib中的字节码文件
5. 使用common类加载器加载CATALINA_HOME/lib下的字节码文件

面试题

1. 既然tomcat不遵循双亲委派机制？那么自己定义一个恶意的hashmap，会不会由风险？
   答：不会，tomcat只是自定义的类加载器不遵循双亲委派机制，但是顶层还是相同的，核心类库还是由引导类加载器来加载
2. Tomcat作为一个web容器，它需要解决什么问题？
   答：共享和隔离问题，多个webapp可能依赖同一个第三方库但版本不同，需要通过不同的webapp类加载器来实现隔离，同时，同一个依赖的相同版本应该可以是共享的