jvm08

类加载机制

虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验，解析和初始化，最终形成可以被虚拟机直接使用的java类型，这就是虚拟机的类加载机制。

类加载时机

初始化

一，遇到new,getstatic,putstatic,invokestatic这四条字节码指令时，如果类没有进行初始化，则先进行初始化。

生成4条指令最常用的场景是，使用new关键字进行实例的时候，读取或设置一个类的静态字段（被final修饰，已在编译器把结果放在常量池的静态字段除外）的时候，以及调用一个了的静态方法的时候。

二，使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没有进行过初始化，则需要先触发其初始化，

三，当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类初始化。

四，当虚拟机启动,用户需要指定一个要执行的主类（包括main()方法的类），虚拟机会先初始化这个主类。

不被初始化的例子

通过子类引用父类的静态字段，

通过数组定义来引用类

调用类的常量。

加载

通过一个类的全限定名来获取定义此类的二进制流

将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。

在内存中生成一个代表这个类的Class对象，作为这个类的各种数据的访问入口。

验证是连接的第一步，这一阶段的目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求并不会危害虚拟机的安全

--文件格式验证

--元数据验证

--字节码验证

--符号引用验证

准备阶段

准备阶段正式为类变量分配内存并设置变量的初始值（即默认值）。但如果被final修饰，这个过程中，常量值会被一同指定。

int 0 

Boolean false

Float 0.0

Char '0'

抽象数据类型  null

这些变量使用的内存都将在方法区中进行分配。

解析

解析阶段是虚拟机将常量池中的符号引用替换为直接引用的过程。

符号引用：使用类的全限定名进行指定

直接引用：直接使用地址指向

类或者接口的解析

字段解析

类方法解析

接口方法解析

初始化是类加载的最后一步

初始化是执行<clinit>()方法的过程。

public class Demo {
    
    static {
           i = 0;
           System.out.println(i); //error
    }

    static int i = 1;
}

编译可通过，输出不通过。
<clinit>()方法是由编译器自动收集类的所有变量的赋值动作和静态语句块中的语句合并而成的，编译器收集的顺序是由语句在源文件中出现的顺序决定的，静态语句中只能访问定义在静态语句块之前的变量,定义在它之后的变量，在前面的语句块可以赋值，但是不能访问。

package com.xuecheng.search;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Demo {

    static class Hello{
        static {
            System.out.println(Thread.currentThread().getName()+"init");

            try {
                Thread.sleep(5000);
            } catch (Exception e) {
                e.printStackTrace();
            }

        }


    }


    public static void main(String[] args) {

        ExecutorService threadPool = Executors.newFixedThreadPool(20);

        int i = 0;

        while(i++<20) {

            threadPool.execute(new Runnable() {

                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"start..");
                    Hello h = new Hello();
                    System.out.println(Thread.currentThread().getName()+"end..");
                }

            });
        }



    }
}

如果多个线程同时初始化一个类，只有一个线程会执行这个类的<clinit>()方法，其他线程等待执行完毕。如果方法执行时间过长，那么就会造成多个线程阻塞。

因此<clinit>是线程安全的

虚拟机的设计把类加载阶段中的 “通过一个类的全限定名来获取描述此类的二进制字节流”这个
动作放到java虚拟机外部去实现，以便让应用程序自己决定如何去获取所需要的类。实现这个动作的代码模块称为类加载器。

只有被同一个类加载器的类才可能会相等，相同的字节码被累加器加载的类不相等。

类加载器的分类

启动类加载器
加载javahome下的lib目录下的类

扩展类加载器
加载javahome下的/lib/ext目录下的类

应用程序类加载器

加载用户类路径上的指定类库

自定义加载器

public class Test {
    
     public static void main(String[] args) throws Exception {
         

            ClassLoader mycl = new ClassLoader() {
                @Override
                public Class<?> loadClass(String name) throws ClassNotFoundException {

                    String fileName = name.substring(name.lastIndexOf(".") + 1) + ".class";
                    InputStream in = getClass().getResourceAsStream(fileName);

                    if (in == null) {
                        return super.loadClass(name);
                    }

                    try {
                        byte[] buff = new byte[in.available()];
                        in.read(buff);
                        return defineClass(name, buff, 0, buff.length);

                    } catch (Exception e) {
                        throw new ClassNotFoundException();
                    }
                }
            };


            Object c = mycl.loadClass("com.roocon.test5.Test").newInstance();

            System.out.println(c.getClass());

            System.out.println(c instanceof Test);

            //Test实际上是应用程序类加载器加载
        }

}

Console:

class com.roocon.test5.Test
false