值得你收藏的类加载、初始化、实例化、加载时机，初始化时机...
文章目录
-
-
- 类加载机制
- 类加载机制分类、类加载器、双亲委派机制
-
- 类加载机制分类
- 类加载器
- 双亲委派机制
- 加载.class文件的方式
- 类生命周期
- 类生命周期结束
- 类加载过程
- JVM初始化步骤
- 类加载时机
- 类初始化时机
- 类的初始化
- 类的实例化
-
平常总是对类的加载，初始化，实例化，类加载机制。。。等等概念容易搞混，这里记录一下！
类加载机制
虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验，转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型的过程就是虚拟机的 类加载机制。
类加载机制分类、类加载器、双亲委派机制
类加载机制分类
- 全盘负责，当一个类加载器负责加载某个Class时，该Class所依赖的和引用的其他Class也将由该类加载器负责载入，除非显示使用另外一个类加载器来载入
-
父类委托（双亲委派），先让父类加载器试图加载该类，只有在父类加载器无法加载该类时才尝试从自己的类路径中加载该类 （这个是JVM采用的！）
-
缓存机制，缓存机制将会保证所有加载过的Class都会被缓存，当程序中需要使用某个Class时，类加载器先从缓存区寻找该Class，只有缓存区不存在，系统才会读取该类对应的二进制数据，并将其转换成Class对象，存入缓存区。这就是为什么修改了Class后，必须重启JVM，程序的修改才会生效
类加载器
虚拟机设计团队把类加载中的“通过一个类的全限定名来获取描述此类的二进制字节流”这个动作放到Java虚拟机外部去实现，以便让应用程序自己决定如何去获取所需要的类。实现这个动作的代码块称为类加载器。
从Java开发人员的角度看，类加载器大致分为如下3种
启动类加载器（Bootstrap Classloader）：负责将存放在
扩展类加载器（Extension Classloader）：该加载器由sun.misc.Launcher$ExtClassLoader实现，它负责加载
应用程序类加载器（Application Classloader）：该加载器由sun.misc.Launcher$AppClassLoader实现，它负责加载用户类路径（ClassPath）上所指定的类库。开发者可以直接使用此加载器。如果应用程序中没有自定义的类加载器，那么这个就是程序默认执行的类加载器。（系统加载器）
我们的应用程序都是由这3种类加载器相互配合进行加载的。如果有必要，还可以加入自定义的类加载器。
这些类加载器之间的关系如下图:
双亲委派机制
双亲委派模型的工作过程是：如果一个类加载器收到了一个类加载请求，它首先不会自己去尝试加载这个类，而是把这个请求委派给父类加载器去完成，每一层的加载器都是如此，因此所有的加载请求最终都应该到达顶层的启动类加载器。只有当父加载无法完成这个加载请求时，子加载器才会尝试自己去加载。
1、当ApplicationClassLoader加载一个class时，它首先不会自己去尝试加载这个类，而是把类加载请求委派给父类加载器ExtClassLoader去完成。
2、当ExtClassLoader加载一个class时，它首先也不会自己去尝试加载这个类，而是把类加载请求委派给BootStrapClassLoader去完成。
3、如果BootStrapClassLoader加载失败（例如在$JAVA_HOME/jre/lib里未查找到该class），会使用ExtClassLoader来尝试加载；
4、若ExtClassLoader也加载失败，则会使用AppClassLoader来加载，如果AppClassLoader也加载失败，则会报出异常ClassNotFoundException。
ClassLoader源码分析：
protected Class loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
// 先检查此类是否已被加载
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;
}
}
双亲委派模型意义：
- 系统类防止内存中出现多份同样的字节码
- 保证Java程序安全稳定运行
加载.class文件的方式
- 从本地系统中直接加载
- 通过网络下载.class文件
- 从zip，jar等归档文件中加载.class文件
- 从专有数据库中提取.class文件
- 将Java源文件动态编译为.class文件
类生命周期
类生命周期结束
在如下几种情况下，Java虚拟机将结束生命周期
-
执行了System.exit()方法
-
程序正常执行结束
-
程序在执行过程中遇到了异常或错误而异常终止
-
由于操作系统出现错误而导致Java虚拟机进程终止
类加载过程
其中类加载的过程包括了加载、验证、准备、解析、初始化五个阶段。 在这五个阶段中，加载、验证、准备和初始化这四个阶段发生的顺序是确定的，而解析阶段则不一定，它在某些情况下可以在初始化阶段之后开始，这是为了支持Java语言的运行时绑定（也成为动态绑定或晚期绑定）。另外注意这里的几个阶段是按顺序开始，而不是按顺序进行或完成，因为这些阶段通常都是互相交叉地混合进行的，通常在一个阶段执行的过程中调用或激活另一个阶段。
-
加载：就是指将class文件读入内存，并为之创建一个Class对象。任何类被使用时系统都会建立一个Class对象。
-
连接：包括以下三个步骤
- 验证：是否有正确的内部结构，并和其他类协调一致
- 准备：负责为类的静态成员分配内存 (所使用的内存都将在方法区中进行分配)，并设置默认初始化值 （注意这里并没有指定具体的值，只是默认值，比如int是0，boolean是false。指定具体的值那是在类的初始化。但是，如果是static final静态常量，则直接指定具体的值！）
- 解析：将常量池内的符号引用替换为直接引用
-
初始化，为类的静态变量赋予正确的初始值，JVM负责对类进行初始化，主要对类变量进行初始化。在Java中对类变量进行初始值设定有两种方式：
①声明类变量并指定初始值
②使用静态代码块为类变量指定初始值
JVM初始化步骤
1、假如这个类还没有被加载和连接，则程序先加载并连接该类
2、假如该类的直接父类还没有被初始化，则先初始化其直接父类
3、假如类中有初始化语句，则系统依次执行这些初始化语句
类加载时机
类加载器并不需要等到某个类被“首次主动使用”时再加载它，JVM规范允许类加载器在预料某个类将要被使用时就预先加载它，如果在预先加载的过程中遇到了.class文件缺失或存在错误，类加载器必须在程序首次主动使用该类时才报告错误（LinkageError错误）如果这个类一直没有被程序主动使用，那么类加载器就不会报告错误
所以什么情况下虚拟机需要开始加载一个类呢？虚拟机规范中并没有对此进行强制约束，这点可以交给虚拟机的具体实现来自由把握。
类初始化时机
注意和上面的类加载时机区别，不要搞混
那么，什么情况下虚拟机需要开始初始化一个类呢？这在虚拟机规范中是有严格规定的，虚拟机规范指明 有且只有 五种情况必须立即对类进行初始化（而这一过程自然发生在加载、验证、准备之后）：
1) 遇到new、getstatic、putstatic或invokestatic这四条字节码指令（注意，newarray指令触发的只是数组类型本身的初始化，而不会导致其相关类型的初始化，比如，new String[]只会直接触发String[]类的初始化，也就是触发对类[Ljava.lang.String的初始化，而直接不会触发String类的初始化）时，如果类没有进行过初始化，则需要先对其进行初始化。生成这四条指令的最常见的Java代码场景是：
-
使用new关键字实例化对象的时候；
-
读取或设置一个类的静态字段（被final修饰，已在编译器把结果放入常量池的静态字段除外）的时候；
-
调用一个类的静态方法的时候。
2) 使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没有进行过初始化，则需要先触发其初始化。
3) 当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
4) 当虚拟机启动时，用户需要指定一个要执行的主类（包含main()方法的那个类），虚拟机会先初始化这个主类。
5) 当使用jdk1.7动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getstatic,REF_putstatic,REF_invokeStatic的方法句柄，并且这个方法句柄所对应的类没有进行初始化，则需要先出触发其初始化。
注意，对于这五种会触发类进行初始化的场景，虚拟机规范中使用了一个很强烈的限定语：“有且只有”，这五种场景中的行为称为对一个类进行 主动引用。除此之外，所有引用类的方式，都不会触发初始化，称为 被动引用。
被动引用的几种经典场景
1)、通过子类引用父类的静态字段，不会导致子类初始化
public class SSClass{
static{
System.out.println("SSClass");
}
}
public class SClass extends SSClass{
static{
System.out.println("SClass init!");
}
public static int value = 123;
public SClass(){
System.out.println("init SClass");
}
}
public class SubClass extends SClass{
static{
System.out.println("SubClass init");
}
static int a;
public SubClass(){
System.out.println("init SubClass");
}
}
public class NotInitialization{
public static void main(String[] args){
System.out.println(SubClass.value);
}
}
/* Output:
SSClass
SClass init!
123
*/
对于静态字段，只有直接定义这个字段的类才会被初始化，因此通过其子类来引用父类中定义的静态字段，只会触发父类的初始化而不会触发子类的初始化。在本例中，由于value字段是在类SClass中定义的，因此该类会被初始化；此外，在初始化类SClass时，虚拟机会发现其父类SSClass还未被初始化，因此虚拟机将先初始化父类SSClass，然后初始化子类SClass，而SubClass始终不会被初始化。
2)、通过数组定义来引用类，不会触发此类的初始化
public class NotInitialization{
public static void main(String[] args){
SClass[] sca = new SClass[10];
}
}
上述案例运行之后并没有任何输出，说明虚拟机并没有初始化类SClass。但是，这段代码触发了另外一个名为[Lcn.edu.tju.rico.SClass的类的初始化。从类名称我们可以看出，这个类代表了元素类型为SClass的一维数组，它是由虚拟机自动生成的，直接继承于Object的子类，创建动作由字节码指令newarray触发。
3)、常量在编译阶段会存入调用类的常量池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化
public class ConstClass{
static{
System.out.println("ConstClass init!");
}
public static final String CONSTANT = "hello world";
}
public class NotInitialization{
public static void main(String[] args){
System.out.println(ConstClass.CONSTANT);
}
}/* Output:
hello world
*///:~
上述代码运行之后，只输出 “hello world”，这是因为虽然在Java源码中引用了ConstClass类中的常量CONSTANT，但是编译阶段将此常量的值“hello world”存储到了NotInitialization常量池中，对常量ConstClass.CONSTANT的引用实际都被转化为NotInitialization类对自身常量池的引用了。也就是说，实际上NotInitialization的Class文件之中并没有ConstClass类的符号引用入口，这两个类在编译为Class文件之后就不存在关系了。
类的初始化
是完成程序执行前的准备工作。在这个阶段，静态的（变量，代码块）会被执行，而静态方法会在第一次调用才执行。同时在会开辟一块存储空间用来存放静态的数据。初始化只在类加载的时候执行一次。
这里贴一张JVM的图：运行时区内存分配
测试类:
public class StaticTest {
public static void main(String[] args) {
System.out.println("-----执行staticFunction()----");
staticFunction();
System.out.println("执行StaticTest st = new StaticTest();");
StaticTest st = new StaticTest();
}
int a = 110; // 实例变量
static int b = 112; // 静态变量
static StaticTest st = new StaticTest();
static { //静态代码块
System.out.println("1");
}
{ // 实例代码块
System.out.println("2");
}
public StaticTest() { // 实例构造器
System.out.println("3");
System.out.println("a=" + a + ",b=" + b);
}
public static void staticFunction() { // 静态方法
System.out.println("4");
}
}
输出结果分析：
前三行输出：是执行static StaticTest st = new StaticTest();相当于在实例化对象，而后由于执行了main方法，所以static静态块执行了，然后才执行staticFunction()。
最后三行输出：就是执行StaticTest st = new StaticTest();,再次创建一个对象，注意这时候不会再执行静态代码块！只会首次执行一次！！
2
3
a=110,b=112
1
-----执行staticFunction()----
4
执行StaticTest st = new StaticTest();
2
3
a=110,b=112
如果把static StaticTest st = new StaticTest();这个去掉，那输出如下：
这里由于不用实例化对象，这里直接进入main方法，会先加载静态代码块,然后执行方法，最后创建对象！
1
-----执行staticFunction()----
4
执行StaticTest st = new StaticTest();
2
3
a=110,b=112
注意，对于这五种会触发类进行初始化的场景，虚拟机规范中使用了一个很强烈的限定语：“有且只有”，这五种场景中的行为称为对一个类进行 主动引用。除此之外，所有引用类的方式，都不会触发初始化，称为 被动引用。
被动引用的几种经典场景
类的实例化
类的实例化也叫对象初始化，这是一个概念。类是对象的抽象，对象是类的具体实例！
是指创建一个对象的过程。这个过程中会在堆中开辟内存，将一些非静态的方法，变量存放在里面。在程序执行的过程中，可以创建多个对象，既多次实例化。每次实例化都会开辟一块新的内存。
可以参考我的另一篇文章进行理解，new 一个对象到底发生了什么？https://blog.csdn.net/belongtocode/article/details/105794529
public class Student {
private String name = "林青霞";
private int age = 27;
public Student() {
name = "刘意";
age = 30;
}
}
class StudentDemo {
public static void main(String[] args) {
Student s = new Student();
}
}
参考文章:
https://www.cnblogs.com/ityouknow/p/5603287.html
https://www.cnblogs.com/chenpt/p/9777367.html
https://blog.csdn.net/qq_39429962/article/details/83190112
https://blog.csdn.net/justloveyou_/article/details/72466105