Java从入门到放弃39—Java内存分析/类的加载过程/类的主动引用和被动引用/Classloader

Java从入门到放弃39—Java内存分析/类的加载过程/类的主动引用和被动引用/Classloader

01 Java内存分析

Java内存区可大致分为堆内存，栈内存以及方法区。

• 堆内存：用于存放new的对象和数组，可以被所有的线程共享，不会存放别的对象引用。
• 栈内存：存放基本变量类型和引用对象变量，存放基本变量类型会包含这个基本类型的具体数值，而存放引用对象的变量会存放这个引用在堆内存中的具体地址值。
• 方法区：可以被所有的线程共享，包含所有的class和static变量。

（注意：jdk1.6常量池放在方法区，jdk1.7常量池放在堆内存，jdk1.8放在元空间里面，和堆相独立。 ）

---

02 类的加载过程

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过Load、Link、Initialize三个步骤对该类进行初始化：

• 类的加载（Load）：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象。
• 类的链接（Link）：将Java类的二进制代码合并到JVM的运行状态之中的过程。
  • 验证：确保加载的类信息符合JVM规范，没有安全方面的问题。
  • 准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。
  • 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。
• 类的初始化（Initialize）：JVM负责对类进行初始化。
  • 执行类构造器()方法的过程。类构造器()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。
  • 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
  • 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步。
• 程序示例

public class Test {

    public static void main(String[] args) {
        
       /*
        1.加载到内存
        2.完成链接后 此时 m = 0;
        3.初始化，进行赋值，静态代码块合并
        
        <clinit>()--->JVM按照顺序合并静态代码块

        <clinit>(){
            m = 300;
            m = 100;
            m = 400;
        }

         */ 
        
        
        
        A a = new A();
        System.out.println(A.m);
        
        /*
        运行结果：
        	A类静态代码块初始化
			A类的构造方法执行了
			400        
        */
        
        
    }

}


class A{

    static int m = 300;

    static{
        System.out.println("A类静态代码块初始化");
        m = 100;
    }

    static {
        m = 400;
    }

    public A() {
        System.out.println("A类的构造方法执行了");
    }
}

---

03 类的主动引用和被动引用

并不是每次引用类都会发生类的初始化：

• 类的主动引用**（一定会发生类的初始化）**

  • 当虚拟机启动，先初始化main方法所在的类
  • new一个类的对象
  • 调用类的静态成员（除了final常量）和静态方法
  • 使用java.lang.reflect包的方法对类进行反射调用
  • 当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类

• 类的被动引用**（不会发生类的初始化）**

  • 当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化
  • 通过数组定义类引用，不会触发此类的初始化
  • 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）

• 程序示例

public class Test {

    public static void main(String[] args) {
        /*
          主动引用1:new一个类的对象,一定会发生该类的初始化.
          当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类.
          调用类的静态成员（除了final常量）和静态方法也会触发初始化.
        */
        
        Son son =  new Son();
        System.out.println(son.m);
        
        /*
          运行结果:
            父类初始化
            子类初始化
            300
        */

       
       //主动引用2:使用java.lang.reflect包的方法对类进行反射调用会进行初始化.
       
       try {
            Class.forName("com.kuang.classloader.Son");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
       
       
       /*
         运行结果:
            父类初始化
            子类初始化
       */

       
       //被动引用1: 通过子类引用父类的静态变量 , 不会导致子类初始化  
       
       System.out.println(Son.b);
      
      /*
          运行结果:
            父类初始化
            2      
      */

       
       //被动引用2:通过数组定义类引用，不会触发此类的初始化
      	
      	
      	Son[] array = new Son[5];


        
        
        //被动引用3:引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）       
        
        
        System.out.println(Son.M);        
       
       
       /*
          运行结果:1
       */

    }

}

class Father{
    
    static int b = 2;
    static {
        System.out.println("父类初始化");
    }
}

class Son extends Father{
    static int m = 100;

    static {
        System.out.println("子类初始化");
        m = 300;//重新赋值m
    }
    //static int m = 100;

    static final int M = 1;//static final修饰的常量存放在常量池中

}

---

04 Classloader

类加载器的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时
数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问
入口。

类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维
持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。

源程序.java文件----(通过Java编译器)----->字节码.class文件------->类装载器------->字节码校验器------->解释器------>操作系统平台

---

类加载器作用是用来把类(class)装载进内存的。JVM 规范定义了如下类型的类的加载器：

• Bootstap Classloader：引导类加载器，由C++编写，是JVM自带的类加载器，负责Java平台核心库，用来装载核心类库。该加载器无法直接获取。
• Extension Classloader：扩展类加载器，负责jre/lib/ext目录下的jar包或 -D java.ext.dirs指定目录下的jar包装入工作库
• System Classloader：负责java -classpath或-D java.class.path所指的目录下的类与jar包装入工作库，是最常用的加载器。

自定义类加载器—>System Classloader—>Extension Classloader—>Bootstap Classloader 按该顺序检查类是否已经装载

Bootstap Classloader—>Extension Classloader—>System Classloader—>自定义类加载器 按该顺序尝试加载类

• 程序示例

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

        //1.获得系统类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);

        //2.获得系统类加载器的父类加载器--->扩展类加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);
        
        //3.扩展类加载器的父类--->根加载器(C++写的)
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1); //null

        //4.通过反射获取当前类是哪个加载器加载的
        ClassLoader classLoader = Class.forName("package_name.class_name").getClassLoader();
        System.out.println(classLoader);

        //5.测试Object类是哪个加载器加载的
        classLoader = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader);

    }
}

---