关于Java ClassLoader:
1. 类加载器是用来把类class装载入JVM的。
Java 运行时会产生三个 ClassLoader:
Bootstrap ClassLoader:称为启动/引导类加载器,是Java类加载层次中最顶层的类加载器,负责加载JDK中的核心类库,如:rt.jar、resources.jar、charsets.jar等;
Bootstrap ClassLoader不继承自ClassLoader,因为它不是一个普通的Java类,底层由C++编写,已嵌入到了JVM内核当中;
ExtClassLoader:负责加载 ext 目录下或者 ext.dir 指定的目录下的类库;
AppClassLoader:负责加载 CLASSPATH 下的类库及类。
当JVM启动后,Bootstrap ClassLoader也随着启动,负责加载完核心类库后,就会加载ExtClassLoader和AppClassLoader。
即AppClassLoader.parent=ExtClassLoader,ExtClassLoader.parent=null(因为Bootstrap ClassLoader不是一个普通的Java类)
2. 加载过程(双亲委托模型):
当一个ClassLoader实例需要加载某个类时,它会试图亲自搜索某个类之前,先把这个任务委托给它的父类加载器,这个过程是由上至下依次检查的,当一个ClassLoader实例需要加载某个类时,它会试图亲自搜索某个类之前,先把这个任务委托给它的父类加载器,这个过程是由上至下依次检查的,
首先由最顶层的类加载器Bootstrap ClassLoader试图加载,如果没加载到,则把任务转交给Extension ClassLoader试图加载,
如果也没加载到,则转交给App ClassLoader进行加载,如果它也没有加载得到的话,则返回给委托的发起者,由它到指定的文件系统或网络等URL中加载该类。
如果它们都没有加载到这个类时,则抛出ClassNotFoundException异常。否则将这个找到的类生成一个类的定义,并将它加载到内存当中,最后返回这个类在内存中的Class实例对象。
3. JVM在判定两个class是否相同时,不仅要判断两个类名是否相同,而且要判断是否由同一个类加载器实例加载的。只有两者同时满足的情况下,JVM才认为这两个class是相同的。

JVM中的几个比较重要的内存区域:

方法区:在JVM中有一块专门用来存放已经加载的类信息、常量、静态变量以及方法代码的内存区域,叫做方法区。
常量池:常量池是方法区的一部分,主要用来存放常量和类中的符号引用等信息。
堆区:用于存放类的对象实例。
栈区:也叫JVM栈,是由一个一个的栈帧组成的后进先出的栈式结构,栈桢中存放方法运行时产生的局部变量、方法出口等信息;
当调用一个方法时,JVM栈中就会创建一个栈帧存放这些数据,当方法调用完成时,栈帧消失,如果方法中调用了其他方法,则继续在栈顶创建新的栈桢。
本地方法栈:
程序计数器:


 Java类的生命周期,即一个class文件从加载到卸载的全过程:

加载--》连接--》初始化--》使用--》卸载

加载:
JVM找到需要加载的类并把类的信息加载到jvm的方法区中,然后在堆区中实例化一个java.lang.Class对象,作为方法区中这个类的信息的入口。
最常用的加载方式有两种,一种是根据类的全路径名找到相应的class文件,然后从class文件中读取文件内容;另一种是从jar文件中读取。
对于加载的时机:常用的hotspot虚拟机是这样处理的-即使“预期”到一个类将要被使用,也会等到真正需要用的时候才会去加载它
(比如,在一段代码中出现了一个类的名字,JVM在执行这段代码之前并不能确定这个类是否会被使用到)
加载阶段之后,是连接阶段。有一点需要注意,就是有时连接阶段并不会等加载阶段完全完成之后才开始,而是交叉进行,可能一个类只加载了一部分之后,连接阶段就已经开始了。
但是这两个阶段总的开始时间和完成时间总是固定的:加载阶段总是在连接阶段之前开始,连接阶段总是在加载阶段完成之后完成。

连接:
连接阶段比较复杂,一般会跟加载阶段和初始化阶段交叉进行,这个阶段的主要任务就是做一些加载后的验证工作以及一些初始化前的准备工作,可以细分为三个步骤:验证、准备和解析。

  1. 验证:当一个类被加载之后,必须要验证一下这个类是否合法,比如这个类是不是符合字节码的格式、变量与方法是不是有重复、数据类型是不是有效、继承与实现是否合乎标准等等。
    总之,这个阶段的目的就是保证加载的类是能够被jvm所运行。
  2. 准备:准备阶段的工作就是为类的静态变量分配内存并设为jvm默认的初值,对于非静态的变量,则不会为它们分配内存。有一点需要注意,这时候,静态变量的初值为jvm默认的初值,而不是我们在程序中设定的初值。jvm默认的初值是这样的:
    基本类型(int、long、short、char、byte、boolean、float、double)的默认值为0。
    引用类型的默认值为null。
    常量的默认值为我们程序中设定的值,比如我们在程序中定义final static int a = 100,则准备阶段中a的初值就是100。

  3. 解析:这一阶段的任务就是把常量池中的符号引用转换为直接引用。
    比如我们要在内存中找一个类里面的一个叫做show的方法,显然是找不到的。
    但是在解析阶段,JVM就会把show这个名字转换为指向方法区的的一块内存地址,比如c17164,通过c17164就可以找到show这个方法具体分配在内存的哪一个区域了。
    这里show就是符号引用,而c17164就是直接引用。在解析阶段,JVM会将所有的类或接口名、字段名、方法名转换为具体的内存地址。

连接阶段完成之后会根据使用的情况(直接引用还是被动引用)来选择是否进入“初始化”阶段。

初始化:

如果一个类被直接引用,就会触发类的初始化。(具体下文“使用”一节会提及)

类的初始化过程:如果有父类,则首先按照顺序自上而下运行父类中的变量赋值语句和静态语句,然后再依次运行子类中的变量赋值语句和静态语句。

示例代码:

 1 class InitClass1 {
 2     public static Field1 f1 = new Field1();
 3     static {
 4         System.out.println("运行父类静态代码");
 5     }
 6     public static Field1 f2;
 7 }
 8 
 9 class SubInitClass1 extends InitClass1 {
10     static {
11         System.out.println("运行子类静态代码");
12     }
13     public static Field2 f2 = new Field2();
14 }
15 
16 class Field1 {
17     public Field1() {
18         System.out.println("Field1构造方法");
19     }
20 }
21 
22 class Field2 {
23     public Field2() {
24         System.out.println("Field2构造方法");
25     }
26 }
27 
28 public class Test1 {
29     public static void main(String[] args) {
30         new SubInitClass1();
31     }
32 }
类的初始化顺序

在类的初始化阶段,只会初始化与类相关的静态赋值语句和静态语句,也就是有static关键字修饰的信息,而没有static修饰的赋值语句和执行语句在实例化对象的时候才会运行。

使用:

在java中,类的使用包括主动引用和被动引用

主动引用的情况有:

  1. 通过new关键字实例化对象、读取或设置类的静态变量、调用类的静态方法;
  2. 通过反射方式执行以上三种行为;
  3. 初始化子类的时候,会触发父类的初始化;
  4. 作为程序入口直接运行时(也就是直接调用main方法)。

除了以上四种情况,其它使用类的方式叫做被动引用(不会触发类的初始化)。

示例代码:

 1 import java.lang.reflect.Field;
 2 import java.lang.reflect.Method;
 3 
 4 class InitClass2 {
 5     static {
 6         System.out.println("初始化InitClass");
 7     }
 8     public static String a = null;
 9 
10     public static void method() {
11     }
12 }
13 
14 class SubInitClass2 extends InitClass2 {
15 }
16 
17 public class Test2 {
18 
19     /**
20      * 主动引用触发类的初始化的示例代码
21      */
22     public static void main(String[] args) throws Exception {
23         // 主动引用引起类的初始化之一
24          new InitClass2();// 实例化对象
25          System.out.println(InitClass2.a);// 读取类的静态变量
26          InitClass2.a = "123";// 设置类的静态变量
27          InitClass2.method();// 调用类的静态方法
28 
29         // 主动引用引起类的初始化之二
30          Class cls = InitClass2.class;
31          Field f = cls.getDeclaredField("a");
32          Method md = cls.getDeclaredMethod("method");
33          cls.newInstance();// 通过反射实例化对象
34          f.get(null);// 通过反射读取类的静态变量
35          f.set(null, "s");// 通过反射设置类的静态变量
36          md.invoke(null, null);// 通过反射调用类的静态方法
37 
38         // 主动引用引起类的初始化之三
39          new SubInitClass2();// 实例化子类->引起父类初始化
40     }
41 }
主动引用

被动引用的情况有:

  1. 引用父类的静态字段,只会引起父类的初始化,而不会引起子类的初始化;
  2. 定义类数组,不会引起类的初始化;
  3. 引用类的常量,不会引起类的初始化。

示例代码:

 1 class InitClass3 {
 2     static {
 3         System.out.println("初始化InitClass");
 4     }
 5     public static String a = null;
 6     public final static String b = "b";
 7 
 8     public static void method() {
 9     }
10 }
11 
12 class SubInitClass3 extends InitClass3 {
13     static {
14         System.out.println("初始化SubInitClass");
15     }
16 }
17 
18 public class Test3 {
19 
20     /**
21      * 被动引用的示例代码
22      */
23     public static void main(String[] args) throws Exception {
24         // String a = SubInitClass3.a;// 引用父类的静态字段,只会引起父类初始化,而不会引起子类的初始化
25         // System.out.println(InitClass3.b);// 读取类的常量不会引起类的初始化
26         // SubInitClass3[] sc = new SubInitClass3[10];// 定义类数组不会引起类的初始化
27     }
28 }
被动引用

 当使用阶段完成之后,java类就进入了卸载阶段。

卸载:

在类使用完之后,如果满足下面的情况,类就会被卸载:

  1. 该类所有的实例都已经被回收,也就是java堆中不存在该类的任何实例;
  2. 加载该类的ClassLoader已经被回收;
  3. 该类对应的java.lang.Class对象没有任何地方被引用,无法在任何地方通过反射访问该类的方法。

如果以上三个条件全部满足,JVM就会在方法区垃圾回收的时候对类进行卸载,类的卸载过程其实就是在方法区中清空类信息,java类的整个生命周期就结束了。