类加载器——ClassLoader

骑猪看日落 2022-07-14 04:46 384阅读 0赞

一、java虚拟机与程序的生命周期
在如下几种情况之下，java虚拟机将结束生命周期：
1、执行了System.exit()方法
2、程序正常执行结束
3、程序在执行过程中遇到了异常或者错误而异常终止
4、由于操作系统用出现错误而导致java虚拟机进程终止
二、类的加载，链接，初始化
1、加载：查找并加载类的二进制数据
2、连接：
（1）验证：确保被加载的类的正确性（验证字节码）
（2）准备：为类的静态变量分配内存，并将其初始化为默认值
（3）解析：把类中的符号引用转换为直接引用
3、初始化：为类的静态成员变量赋予正确的初始值

  1. public class test(){
  2.    private static int a=3;
  3. }
  4. 首先在准备阶段java虚拟在内存中为a分配内存，int的初始值是0，所以此时a的值是0；在初始化阶段，给赋值为3
  5. 相当于：
  6. public class test(){
  7.    private static int a;
  8.    //从上到下执行
  9.    static{
  10.       a=3;
  11.   }
  12. }

这里写图片描述
java程序对类的使用方式可分为两种：
（1）主动使用
* 创建类的实例。比如：new Test()
* 访问某个类或者接口的静态变量，或者对该静态变量赋值。比如：int b=Test.a
* 调用类的静态方法。例如：Test.doSomething();
* 反射(如class.forName(“com.jvm.classloader.test”))
* 初始化一个类的子类(对父类的主动使用)。例如：

  1. class Parent { 
  2. }
  3. class Child extends Parent{ 
  4.   public static int a=4;
  5. }
  6. Child.a=8;

*java虚拟机启动时被表明为启动类的类
（2） 被动使用：除去以上六种主动使用以外的使用都是被动使用，都不会导致类的初始化。所有的java虚拟机实现必须在每个类或接口被java程序首次主动使用时才初始化他们。
（3）类的加载指的是将类的.class文件中的二进制数据读入到内存中，将其方法运行时数据区的方法区内。然后在堆区创建一个Java.lang.Class对象，用来封装在类在方法区内的数据结构。
这里写图片描述
（4）加载.class文件的方式
* 从本地系统中直接加载
* 通过网络下载.class文件(java.net.URLClassLoader(URL[] urls))
* 从zip，jar等归档文件中加载.class文件
* 从专有数据库中提取.class文件
* 将java源文件动态编译为.class文件。
（5）类的加载的最终产品是位于堆区中的Class对象
（6）Class对象封装了类在方法区内的数据结构，并且向Java程序员提供了访问方法区内的数据结构的接口。
（7）两种类型的类加载器：
* Java虚拟机自带的加载器
* *根类加载器(Bootstrap)。使用C++编写，程序员无法在java代码中获得该类。
* *扩展类加载器（Extension），使用java代码实现
** 系统类加载器(System)，应用加载器，使用java代码实现
* 用户自定义的类加载器
* *java.lang.ClassLoader的子类
* *用户可以定制类的加载方式
public ClassLoader getClassLoader()方法。针对这个类返回一个个加载器，但是某些实现可能会返回null代表根类加载器。如果使用根类加载器加载类，那么这个方法就会返回null；
例：

  1. public class BootStrapTest { 
  2.       public static void main(String[] args) throws Exception {
  3.             Class clazz=Class.forName("java.lang.String");
  4.             ClassLoader loader=clazz.getClassLoader();
  5.             /** * 打印结果为null */
  6.             System.err.println(loader);
  8.           Class clazz2=Class.forName("com.jvm.classloader.C");
  9.           ClassLoader loader2=clazz2.getClassLoader();
  10.           /** * 打印结果为：sun.misc.Launcher$AppClassLoader@54a5f709 应用加载器 */
  11.           System.err.println(loader2);
  12.       }
  13. }
  14. class C{
  16. }

（8） 类加载器并不需要某个类被首次主动使用时再加载他。
（9） JVM规范允许类加载器在预料某个类将要被使用时就预先加载它，如果在预先加载的过程中遇到了.class文件缺失或存在错误，类加载器必须在程序首次主动使用该类时才报告错误(LinkageError错误)
（10） 如果这个类一直没有被程序主动使用，那么类加载器就不会报告错误。
（11）类被加载后，就进入连接阶段。连接就是将已经读入到内存的类的二进制数据合并到虚拟机的运行时环境中去。
（12）类的验证的内容：
* 类文件的结构检查：确保类文件遵从java类文件的固定格式。
* 语义检查：确保类本身符合java语言的语法规定，比如验证final类型的类没有子类，以及final类型的方法没有被覆盖。（虽然编译时就可以发现错误，但不经过编译，手动生成class文件，那么就会发现不了final类型的方法被覆盖，但是语义检查就可以发现）
* 字节码验证：确保字节码流可以被java虚拟机安全的执行。字节码流代表java方法（报空静态方法和实例方法），它是由被称作操作码的单字节指令组成的序列，每一个操作码后跟着一个或多个操作数。字节码验证步骤会检查每个操作码是否合法，即是否有着合法的操作数。
* 二进制兼容性的验证：确保相互引用的类之间的协调一致，例如在Wroker类的gotoWork()方法中会调用Car类的run()方法。java虚拟机在验证work()类时，会检查在方法区内是否存在Car类的run()方法，假如不存在（当worker类和Car类的版本不兼容，就会出现这种问题），就会抛出NoSuchMethodError方法。
（13）类的准备：在准备阶段，Java虚拟机为类的静态变量分配内存，并设置默认的初始值。例如对于一下Sample类，在准备阶端，将为int类型的静态变量a分配4个字节的内存空间，并且赋予默认值0，为long类型的静态变量b分配8个字节的内存空间，并且赋予默认值0。

  1. public class Sample{
  2.     private static int a=1;
  3.     public static long b;
  5.     static{
  6.      b=2;
  7.    }
  8. }

（14）类的解析：在解析阶段，java虚拟机会把类的二进制数据中的符号引用替换为直接引用。例如在Worker类的gotoWork()方法中会引用Car类的run()方法。

  1. public void gotoWork(){
  2.    car.run();//这段代码在worker类的二进制数据中表示为符号引用
  3. }

在Worker类中的二进制数据中，包含了一个对Car类的run()方法的符号引用，它由run()方法的全名和相关描述符组成。在解析阶段，Java虚拟机会把这个符号替换为一个指针，该指针指向Car类的run()方法在方法区内的内存位置。这个指针就是直接引用。
类的初始化：在初始化阶段，java虚拟机执行类的初始化语句，为类的静态变量赋予初始值。在程序中，静态变量初始化有两种途径：
1、类的初始化：在初始化阶段，java虚拟机执行类的初始化语句，为类的静态变量赋予初始值。在程序中，静态变量初始化有两种途径：
（1）在静态变量的声明处进行初始化；
（2）在静态代码快中进行初始化。例如在以下代码中，静态变量a和b都被显示初始化，而静态变量c没有被显示初始化，它将保持默认值为0；

  1. public class Sample{
  2.     private static int a=1;     //在静态变量声明出进行初始化
  3.     public static long b;
  4.     public static long c;
  5.     static{
  6.      b=2;                      //在静态代码块中进行初始化
  7.    }
  8. }

实例：

  1. public class ClassLoaderTest { 
  2.       public static void main(String[] args) {
  3.             Singleton singleton=Singleton.getInstance();
  4.             System.out.println("counter1= "+singleton.counter1);
  5.             System.out.println("counter2= "+singleton.counter2);
  6.       }
  7. }
  8. /** *程序是从上向下顺序执行 * new Singleton()时，counter1，counter2初始值均为0 * 在通过构造方法Singleton()，均加1.则返回的值counter1，counter2均为1 * 然后再程序在继续向下执行，由于counter1没有显示初始化，则值还是为1 * 但是counter2经过显示初始化后，其值为0 * @author zhaojw_420 */
  9. class Singleton{
  10.       private static Singleton singleton=new Singleton();//new语句在这是结果为counter1= 1；counter2= 0
  11.       public static int counter1;
  12.       public static int counter2=0;
  14.       //private static Singleton singleton=new Singleton();//new语句在这是结果为counter1= 1；counter2= 1
  15.       private Singleton(){
  16.             counter1++;
  17.             counter2++;
  18.       }
  19.       public static Singleton getInstance(){
  20.             return singleton;
  21.       }
  22. }

2、静态变量的声明语句，以及静态代码块都被看做类的初始化语句，java虚拟机会按照初始化语句在类文件中的先后顺序来一次执行他们。例如：
3、类的初始化步骤：
（1）假如这个类还没有被加载和连接，那就先进行加载和连接
（2）假如类存在直接的父类，并且这个父类还没有被初始化，那就先初始化直接的父类。
（3）假如父类中存在初始化语句，那就依次执行这些初始化语句。

  1. public class FinalTest { 
  2.       public static void main(String[] args) {
  3.             System.err.println(Test.X);
  4.       }
  5. }
  6. /** * 当X=6/3时，编译时即可算出X=2，即编译时常量，即不需要运行类，所以不打印静态代码块中的内容 * 当X=new Random().nextInt(100)时，编译时不能算出X的值，只有运行程序才知道，所以打印结果为：FinalTest static final 2 * @author zhaojw_420 * */
  7. class Test{
  8.       public static final int X=6/3;//打印结果： 2
  10.       //public static final int X=new Random().nextInt(100);//打印结果为FinalTest static final 2
  12.       static{
  13.             System.err.println("FinalTest static final");
  14.       }
  15. }

4、类的初始化时机：当java虚拟机初始化一个类时，要求他的所有父类都已经被初始化，但是这条跪着并不适用于接口。
（1）在初始化一个类时，并不先初始化它所实现的接口
（2）在初始化一个接口时，并不会先初始化他的父接口。
因此，一个父接口并不会因为他的子接口或者实现类的初始化而初始化。只有当程序首次使用特定接口的静态变量时，才会导致该接口的初始化。

  1. public class Test4 { 
  2.       static {
  3.             System.err.println("Test4 static block");
  4.       }
  5.       public static void main(String[] args) {
  6.             System.err.println(Child.b);
  7.       }
  8. }
  9. /** * Test4 static block * Parent static block * Child static block * 4 * @author zhaojw_420 * */
  10. class Parent{
  11.       public static final int a=3;
  13.       static{
  14.             System.err.println("Parent static block");
  15.       }
  16. }
  17. class Child extends Parent{
  18.       public static int b=4;
  20.       static{
  21.         System.err.println("Child static block");
  22.       }
  23. }

（5）程序中对子类的“主动使用”会导致父类被初始化，但对父类的“主动使用”并不会导致子类初始化，不可能说生成一个Object类的对象就导致系统中所有的子类都会被初始化。

  1. public class Test5 { 
  2.       static{
  3.             System.err.println("Test5 static block");
  4.       }
  5.       public static void main(String[] args) {
  6.             Parent2 parent;
  7.             System.err.println("-------------");
  8.             parent=new Parent2();
  9.             System.err.println(Parent2.a);
  10.             System.err.println(Child2.b);
  11.       }
  12. }
  13. /** * Test5 static block * ------------- * Parent2 static block * 3 * Child2 static block * 4 * */
  14. class Parent2{ 
  15.       public static final int a=3;
  17.       static{
  18.             System.err.println("Parent2 static block");
  19.       }
  20. }
  21. class Child2 extends Parent2{ 
  22.       public static int b=4;
  24.       static{
  25.         System.err.println("Child2 static block");
  26.       }
  27. }

（6）只有当程序访问的静态变量或静态方法确实在当前接口定义时，才可以认为是对类或接口的主动使用。

  1. public class Test6 { 
  2.       public static void main(String[] args) {
  3.             System.err.println(Child3.a);
  4.             Child3.doSomething();
  5.       }
  6. }
  7. /** * Parent3 static block * 3 * doSomething * @author zhaojw_420 * */
  8. class Parent3{ 
  9.       static int a=3;
  11.       static {
  12.             System.err.println("Parent3 static block");
  13.       }
  14.       static void doSomething(){
  15.             System.err.println("doSomething");
  16.       }
  17. }
  18. class Child3 extends Parent3{ 
  19.       static{
  20.             System.err.println("Child3 static block");
  21.       }
  22. }

（7）调用ClassLoader类的loadClass方法加载一个类，并不是对类的主动使用，不会导致类的初始化。

  1. public class Test7 { 
  2.       public static void main(String[] args) throws ClassNotFoundException {
  3.             ClassLoader loader=ClassLoader.getSystemClassLoader();
  4.             Class<?> clazz=loader.loadClass("com.jvm.classloader.Z");
  5.             System.err.println("------------------------");
  6.             clazz=Class.forName("com.jvm.classloader.Z");
  7.       }
  8. }
  9. /** * ------------------------ *Z static block * @author zhaojw_420 * */
  10. class Z{
  11.       static{
  12.             System.err.println("Z static block");
  13.       }
  14. }

发表评论

表情：
评论列表 （有 0 条评论，384人围观）

还没有评论，来说两句吧...

相关阅读

    相关 ClassLoader类加载器

    ClassLoader 类加载器 Class类描述的是整个类的信息，在Class类中提供的forName()方法,这个方法根据ClassPath配置的路径进行类的加载，如

    桃扇骨桃扇骨/ 0 赞/ 586 阅读