关于jvm:类的加载过程面试必问

类的加载过程

1. loading 加载

   通过双亲委派机制进行加载。次要出于平安的思考。父加载器不是加载器的加载器，也不是父类加载的加载器。

2. linking 链接
3. verification 验证
4. preparation 筹备 动态变量赋默认值，private static int test =10; 在这个阶段只是 test 赋默认值 0，而不是 10。
5. resolution 解析 将类、办法、属性等符号援用解析为间接援用。常量池中的各种符号援用解析为指针，偏移量等内存地址的间接援用。
6. initalizing 初始化  private static int test =10 在这一步才会被赋值成 test=10

类的加载过程

public class T002_ClassLoaderLevel {public static void main(String[] args) {
      // 由顶层类 Bootstrap 加载
      System.out.println(String.class.getClassLoader());

      System.out.println(sun.net.spi.nameservice.dns.DNSNameService.class.getClassLoader());
      System.out.println(T002_ClassLoaderLevel.class.getClassLoader());
      System.out.println(sun.net.spi.nameservice.dns.DNSNameService.class.getClassLoader().getClass().getClassLoader());
      System.out.println(T002_ClassLoaderLevel.class.getClassLoader().getClass().getClassLoader());
      System.out.println(new T006_MSBClassLoader().getParent());
      System.out.println(ClassLoader.getSystemClassLoader());
    }
}

每个类被加载后都会产生一个对应的 class 对象，咱们能够通过 class 对象去获取。输入后果为：

null
sun.misc.Launcher$ExtClassLoader@5e2de80c
sun.misc.Launcher$AppClassLoader@18b4aac2
null
null
sun.misc.Launcher$AppClassLoader@18b4aac2
sun.misc.Launcher$AppClassLoader@18b4aac2

咱们先看了一下 String 的 ClassLoad，String 是属于外围类库，应用顶层类加载器 Bootstrap 加载，所以打印为 null，sun.net.spi.nameservice.dns.DNSNameService 的 ClassLoad 是 ExtClassLoader，而后咱们通过 System.out.println(sun.net.spi.nameservice.dns.DNSNameService.class.getClassLoader().getClass().getClassLoader()); 获取 DNSNameService 的加载器的加载器也就是 ExtClassLoader 的在加载器打印也为 null，也就是说 ExtClassLoader 的加载器是 Bootrap。各种加载器的层级关系如下图

一个类被加载到内存中的过程是先依照右边的箭头方向以此判断是否曾经被加载，如果到了 Bootstrap 发现没有被加载，则会依照有测箭头方向顺次向下执行加载操作，如果咱们有个自定义加载器的类第一次被加载，过程为：去查看 CustomClassLoad 是否曾经加载 = 否 > 查看 AppClassLoad= 否 > 查看 ExtensionClassLoad= 否 > 查看 Bootstrap= 否 >Bootstrap 尝试加载，不是外围类库 =>ExtensionClassLoad 加载 = 没有找到 >AppClassLoad 加载 = 没有找到 >CustomClassLoad 加载胜利加载或者抛出异样 ClassNotFoundException，咱们通常说 Bootstrap 是所以加载器的父类，custom ClassLoad 是底层加载器，是不是意味着下面的图就是依照 Bootstrap=>Extension=>APP=>Custom ClassLoad 的继承关系过去的呢？答案是否定的，下面的关系并不是依照继承的关系来的。他们是依照下图的形式继承的。比方 CustomClassLoad 的父加载器是 AppClassLoad，是 CustomClassLoad 的成员变量中保留了 AppClassLoad。

问：为什么要应用双亲委派机制？

次要是为了平安。如果所有的加载操作都应用一个类加载，我就能够本人自定义一个外围类库比方 String 去笼罩 jdk 提供的 String，咱们当初应用双亲委派机制，每次加载一个类都会先向查看是否曾经被加载如果曾经被加载间接返回。同时下层曾经加载实现上层就不须要加载了。

上面通过一个小程序查看一下不同的加载器别离加载了哪些货色。

public class T003_ClassLoaderScope {public static void main(String[] args) {String pathBoot = System.getProperty("sun.boot.class.path");
        System.out.println(pathBoot.replaceAll(";", System.lineSeparator()));

        System.out.println("--------------------");
        String pathExt = System.getProperty("java.ext.dirs");
        System.out.println(pathExt.replaceAll(";", System.lineSeparator()));

        System.out.println("--------------------");
        String pathApp = System.getProperty("java.class.path");
        System.out.println(pathApp.replaceAll(";", System.lineSeparator()));
    }
}

输入后果为：

/Library/Java/JavaVirtualMachines/jdk1.8.0_231.jdk/Contents/Home/jre/lib/resources.jar
:/Library/Java/JavaVirtualMachines/jdk1.8.0_231.jdk/Contents/Home/jre/lib/rt.jar
:/Library/Java/JavaVirtualMachines/jdk1.8.0_231.jdk/Contents/Home/jre/lib/sunrsasign.jar
:/Library/Java/JavaVirtualMachines/jdk1.8.0_231.jdk/Contents/Home/jre/lib/jsse.jar
:/Library/Java/JavaVirtualMachines/jdk1.8.0_231.jdk/Contents/Home/jre/lib/jce.jar
:/Library/Java/JavaVirtualMachines/jdk1.8.0_231.jdk/Contents/Home/jre/lib/charsets.jar
:/Library/Java/JavaVirtualMachines/jdk1.8.0_231.jdk/Contents/Home/jre/lib/jfr.jar
:/Library/Java/JavaVirtualMachines/jdk1.8.0_231.jdk/Contents/Home/jre/classes
--------------------
/Users/yanghongxing/Library/Java/Extensions
:/Library/Java/JavaVirtualMachines/jdk1.8.0_231.jdk/Contents/Home/jre/lib/ext
:/Library/Java/Extensions:/Network/Library/Java/Extensions:/System/Library/Java/Extensions
:/usr/lib/java
--------------------
/Users/yanghongxing/Library/Application Support/Code/User/workspaceStorage/7172d33d4189eaa64607305e947a5428/redhat.java/jdt_ws/src_28ac311/bin

如何实现一个自定义类加载器

首先搞清楚一件事，如果咱们要加载一个类怎么写？咱们间接调用 AppClassLoad 的 loadClass() 办法即可

public class Test {public static void main(String[] args) throws ClassNotFoundException {
  // 执行加载操作
  Class clazz = Test.class.getClassLoader().loadClass("com.yhx.test.Test1");
        
        System.out.println(clazz.getName());
    }
}

上面咱们看一下加载过程的源码：

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 {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();
                    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;
        }
  .....
    protected Class<?> findClass(String name) throws ClassNotFoundException {throw new ClassNotFoundException(name);
    }
  
    }

先开始通过 findLoadedClass(name) 查看是否曾经加载过，返回 null 则没有被加载，调用父类的 findLoadedClass(name) 查看办法返回，这一部分就相当于咱们之前的双亲委派的加载示意图的右边的箭头，查看是否被加载，如果全部都是未加载，开始执行示意图的右半局部，long t1 = System.nanoTime(); c = findClass(name); 调用 findClass 这个办法，然而这个办法就间接抛出异样。（所以咱们再实现自定义加载器只有继承 ClassLoader 重写其中的 findClass 办法即可）抛出异样会被子类捕捉，子类就会反复执行 find 操作。

public class Test extends ClassLoader {

    public static int seed = 0B10110110;

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {File f = new File("/Users/yanghongxing/Downloads", name.replace('.', '/').concat(".testclass"));

        try {FileInputStream fis = new FileInputStream(f);
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            int b = 0;

            while ((b=fis.read()) !=0) {baos.write(b ^ seed);
            }

            byte[] bytes = baos.toByteArray();
            baos.close();
            fis.close();
            // 这个办法能够把二进制流转换成 class 对象
            return defineClass(name, bytes, 0, bytes.length);
        } catch (Exception e) {e.printStackTrace();
        }
        return super.findClass(name); //throws ClassNotFoundException
    }
  }

编译器

• 解释器  – bytecode inpetreter 将字节码解释为操作系统能辨认的机器码。

• 即时编译器 JTT -Just In Time Compiler，建字节码编译成机器码。

  Java 默认应用混合模式，起始阶段应用解释执行，运行时采纳热点代码检测，屡次被调用的办法（办法计数器：检测执行频率）屡次调用的循环（循环计数器：检测循环调用的频率）应用参数 -Xmixed 混合模式 -Xint 解释模式 -Xcopm 编译模式

面试题

上面的代码执行后果是怎么样的？

public class Test {public static void main(String[] args) {System.out.println(T.count);
    }
}

class T {public static T t = new T(); // null
    public static int count = 2; //0

    //private int m = 8;

    private T() {count ++;}
}

后果为 2. 咱们剖析一下类 T 的加载过程，类在在加载时，加载给 1. 加载，2. 链接，2.1 校验，2.2 筹备，给动态成员变量赋初始值 T t =null，int count=0。2.3 解析，将类、办法、属性等符号援用解析为间接援用，T t 指向 new T（）并执行 t 的构造方法，此时执行 count++，count=1。3 初始化，count=2。输入 2。

思考：上面的代码执行后果如何？

public class Test {public static void main(String[] args) {System.out.println(T.count);
    }
}

class T {
   public static int count = 2; 
  public static T t = new T(); 
   

    //private int m = 8;

    private T() {count ++;}
}