JAVA类加载机制

Dear 丶 2022-02-05 12:09 274阅读 0赞

# JAVA类加载机制 #

## 问题 ##

### 第一个问题 ###

package xuelongjiang;
    
    class SingleTon { 
        private static SingleTon singleTon = new SingleTon();
        public static int count1;
        public static int count2 = 0;
    
        private SingleTon() { 
            count1++;
            count2++;
        }
    
        public static SingleTon getInstance() { 
            return singleTon;
        }
    }
    
    public class Test { 
        public static void main(String[] args) { 
            SingleTon singleTon = SingleTon.getInstance();
            System.out.println("count1=" + singleTon.count1);
            System.out.println("count2=" + singleTon.count2);
        }
    }

输出是什么呢？  
先给出答案：

count1 = 1;
    count2 = 0;

### 第二个问题 ###

package xuelongjiang;
    
    class Grandpa
    { 
        static
        { 
            System.out.println("爷爷在静态代码块");
        }
    }    
    class Father extends Grandpa
    { 
        static
        { 
            System.out.println("爸爸在静态代码块");
        }
    
        public static int factor = 25;
    
        public Father()
        { 
            System.out.println("我是爸爸~");
        }
    }
    class Son extends Father
    { 
        static 
        { 
            System.out.println("儿子在静态代码块");
        }
    
        public Son()
        { 
            System.out.println("我是儿子~");
        }
    }
    public class InitializationDemo
    { 
        public static void main(String[] args)
        { 
            System.out.println("爸爸的岁数:" + Son.factor);  //入口
        }
    }

输出是什么呢？  
先给出答案

爷爷在静态代码块
    爸爸在静态代码块
    爸爸的岁数:25

如果两个问题都你认为的输出个上面的答案一样，那么直接跳到最后挑战一下最后的一个问题，如果没有回答正确也没关系，看完本文相信你，以后遇到相同的问题，就能准确的说出答案了。

## 类生命周期的七个阶段 ##

![879896-20160414224549770-60006655.png][]  
(图片来源互联网)

一个类的生命周期为：加载、验证、准备、解析、初始化、使用、卸载。  
其中加载、验证、准备、解析、初始化这五个阶段是类加载的过程。我们着重说明这五个阶段。

### 加载 ###

**加载**也就是把字节码加载进虚拟机转化为方法区的运行时数据结构。字节码来源可以是：javac编译的字节码、自己写的16进制字节码。

### 验证 ###

为了确保虚拟机的安全，我们从加载过程中知道字节码的来源可能是其他人没有通过javac编译生成的字节码，所以为了保证虚拟机不被破坏，虚拟机需要验证加载进来的字节码。

验证阶段分为三个方面的验证：

1.  文件格式的验证 检查魔术数、主次版本是否符合范围
2.  元数据的验证 检查语法是否正确 例如：所有类是否有父类（除过Object）
3.  字节码验证 数据流和控制流的分析  
    其实也就是JVM规范校验、代码逻辑校验。

### 准备 ###

准备阶段会给类变量分配内存空间和设置变量初始值。注意这里只是给类变量分配内存空间和设置初始值，而不是给实例变量。

类有变量：

public static int value = 123;

在完成准备阶段后，value的值是0，这里只是给变量设置了**初始值**，等到初始化阶段完成，value的值为123。

但是如果**常量**的话，则会在**准备**阶段完成赋值。

public final  static  int value = 123;

上面代码在完成准备阶段后，value的值则为123。这是因为**final**修饰表示此变量为常量。赋值之后不会被再被修改了。

需要注意实例变量分配内存是在类实例化的时候进行的。

### 解析 ###

解析阶段实际上是对类中的引用进行解析。

### 初始化 ###

初始化阶段是最为重要的阶段，这里会完成在准备阶段中初始化的类变量的赋值。

虚拟机规范了有且只有五种情况必须立即对类进行初始化

1.  遇到new、getstatic、putstatic、invokestatic这四条字节码指令时如果没有初始化要进行初始化。这四条指令对应的是，当new一个对象时、读取静态变量、设置静态变量、调用静态方法。
2.  使用反射的时候，如果类没有进行初始化要触发初始化。
3.  当初始化一个类的时候，如果发现父类还没有进行初始化，则需要先触发其父类的初始化。
4.  当虚拟机启动的时候，用户需要指定一个要执行的主类（也就是包含main方法的那个类）,虚拟机会先初始化这个主类。
5.  当使用 JDK1.7 动态语言支持时，如果一个 java.lang.invoke.MethodHandle实例最后的解析结果 REF\_getstatic,REF\_putstatic,REF\_invokeStatic 的方法句柄，并且这个方法句柄所对应的类没有进行初始化，则需要先出触发其初始化。 也就是在静态方法作为参数的时候.

**关于<clinit>方法**

1.  初始化的过程就是执行方法的过程，这个方法是有编译器自动收集类中的所有类变量的赋值动作和静态语句块中的语句合并产生的。收集顺序是由代码在源文件中出现的顺序，也就是按照顺序执行。
2.  不会显式的调用父类的方法，而是由虚拟机保证先执行父类的方法
3.  由于第2点，所以父类中的静态语句要有优先于子类执行。
4.  在多线程环境中会虚拟机会保证被正确的加锁和同步。

## 第一个问题分析 ##

现在我们来分析上面第一个问题：

main方法调用getInstance方法会是SingleTon类初始化，并且执行是从上到下，首先执行语句：

private static SingleTon singleTon = new SingleTon();
    
    new SingleTon();会触发构造器
    
    执行 
    
    private SingleTon() { 
            count1++;
            count2++;
        }
    此时count1,count2在准备阶段被初始化为0，那么此时count1 = 1,count2 = 1，之后执行
    public static int count1;
    语句此时只是声明变量，我们知道类变量可以被先赋值再声明。所以此时count1 = 1；
    
    接下里执行
     public static int count2 = 0;
     这里赋值count2 = 0。所以此时count2 = 0;
    
    最后执行
    
     System.out.println("count1=" + singleTon.count1);
            System.out.println("count2=" + singleTon.count2);
    
    输出结果
    count1 = 1;
    count2 = 0;

## 第二个问题分析 ##

我们再来分析第二个问题。我们知道会先执行父类。Son.factor中factor被声明在Father类中，所以这里不会初始化Son类，而Grandpa又是Father的父类。所以初始化顺序是 Grandpa —> Father  
所以输出是

爷爷在静态代码块
    爸爸在静态代码块
    爸爸的岁数:25

## 最后一个问题 ##

现在我们再看一个有点难的问题：

package xuelongjiang;
    
    public class Book { 
        public static void main(String[] args)
        { 
            staticFunction();
        }
    
        static Book book = new Book();
    
        static
        { 
            System.out.println("书的静态代码块");
        }
    
        { 
            System.out.println("书的普通代码块");
        }
    
        Book()
        { 
            System.out.println("书的构造方法");
            System.out.println("price=" + price +",amount=" + amount);
        }
    
        public static void staticFunction(){ 
            System.out.println("书的静态方法");
        }
    
        int price = 110;
        static int amount = 112;
    }

输出是什么呢？

我们现在分析

当虚拟机启动的时候，用户需要指定一个要执行的主类（也就是包含main方法的那个类）,虚拟机会先初始化这个主类。

首先执行

Static Book book = new Book();

上面的代码会触发执行Book的实例化执行下面代码

{ 
            System.out.println("书的普通代码块");
        }

构造方法：

System.out.println("书的构造方法");
            System.out.println("price=" + price +",amount=" + amount);

此时price会赋值为110,而amount只是被初始化为0，还未赋值。

接下来执行静态代码：

static
      { 
          System.out.println("书的静态代码块");
      }