java虚拟机类加载机制

大家先看一段代码：

package test;

public class StaticTest {

 public static void main(String[] args)

    {

        staticFunction();

    }

    static StaticTestst =new StaticTest();

    static

    {

        System.out.println("1");

    }

    {

        System.out.println("2");

    }

    StaticTest()

    {

        System.out.println("3");

        System.out.println("a="+a+",b="+b);

    }

    public static void staticFunction(){

        System.out.println("4");

    }

    int a=110;

    static int b =112;

}

大家觉得以上代码会是什么输出结果呢？如果大家推想的和验证的结果一致，那么恭喜你，你的java虚拟机的整个初始化过程已经了如指掌了，下面的你可以略过，如果有问题，不妨耐下心来看看以下的整个虚拟机的类加载过程。

若想知道为什么会输出这个结果，答案在文末。

1. 概述

虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的java类型，这就是虚拟机的类加载机制。

在java语言里面，类型的加载，连接和初始化过程都是在程序运行期间完成的，这种策略虽然会令类加载时稍微增加一些性能开销，但却给java应用程序提供更高的灵活性，java运行期的动态类型绑定就是依赖于这种加载机制。

2. 类加载时机

类从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期包括：加载、验证、准备、解析、初始化、使用和卸载7个阶段，其中验证、准备、解析3个部分统称为连接，这7个阶段时序图如图1-1所示。

图1-1 类的生命周期

 

图1-1，加载、验证、准备、初始化和卸载这5个阶段得顺序是确定的，类的加载过程必须按照这种顺序按部就班地开始，但是这些阶段通常都是互相交叉地混合式进行的，通常会在一个阶段执行的过程中调用激活另一个阶段，但是基本的顺序是保持不变的，而解析阶段则不一定：它在、某些情况下可以在初始化阶段之后再开始，这是为了支持java语言的动态绑定。

类什么时候加载虚拟机并没有强制性约束，但是对于初始化阶段，虚拟机规范则是严格规定了有且只有5种情况必须立即对类进行初始化（而加载、验证、准备自然要在此之前开始）：
1）在使用new关建字实例化对象的时候，读取或设置一个类的静态字段（常量除外）的时候，以及条用一个类的静态方法的时候。

2）使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没有进行过初始化，则要先触发其初始化。

3）当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先初始化其父类。

4）当虚拟机启动的时，用于需要指定一个要执行的主类（main方法所在的类），虚拟机会先初始化这个主类。

5）当使用jdk1.7动态语言支持时，例如动态代理。

除了上述这5种场景外，我们将其它引用类的方式都不会触发其初始化的这种方式称为被动引用，下面以几个例子来看下。

代码1-1 静态字段初始化

/**

 * 通过子类调用父类的静态字段，不会导致子类初始化

 */

public class SuperClass {

 

static {

System.out.println("SuperClass init");

}

public static int value=123;

}

/**

 * 非主动使用类字段演示

 */

public class ChildClassextends SuperClass{

 

static{

System.out.println("ChildClass init");

}

}

public class Test1 {

public static void main(String[] args) {

// TODO Auto-generated method stub

System.out.println(ChildClass.value);

}

}

输出结果：

SuperClass init

123

从输出结果上看，父类进行了初始化动作，而子类没有。对于静态字段，只有直接定义这个字段的类才会被初始化，因此通过子类引用父类中定义的静态字段，只会触发父类的初始化。

代码1-2 被动引用一

/**

 * 常量在编译阶段会存入类的常量池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量类的初始化。

 */

public class ConstClass {

static{

System.out.println("ConstClass init");

}

public static final int value=123;

}

public class Test1 {

public static void main(String[] args) {

// TODO Auto-generated method stub

System.out.println(ConstClass.value);

}

}

在这里需强调下接口中的常量问题，它与类的主要区别：当一个类在初始化时，要求其父类全部都已经初始化过了，但是一个接口在初始化时，并不要求其父接口全部都完成了初始化，只有在真正使用到父接口的时候（如引用接口中定义的常量）才会初始化。

代码1-3 被动引用二

/**

 * 通过数组定义来引用类，不会触发此类的初始化

 */

public class Test1 {

public static void main(String[] args) {

// TODO Auto-generated method stub

SuperClass[]sca=new SuperClass[10];

}

}

3. 类加载的过程

接下来我们详细讲解一下java虚拟机类加载的全过程，也就是加载、验证、准备、解析和初始化这5个阶段所执行的具体动作。

加载

在加载阶段，虚拟机需要完成以下3件事情：

1）通过一个类的全限定名来获取定义此类的二进制字节流。

2）将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。

3）在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据得访问接口。

虚拟机对这3点要求并不具体，第一条并未指明从一个Class文件获取字节流，因此我们可以通过像压缩包、网络等途径获取。

对于类的加载阶段也是开发人员可控性最强的，程序员可以自己编写类加载器来完成类的加载。

加载阶段与连接阶段得部分内容是交叉进行的，加载阶段尚未完成，连接阶段可能已经开始，但这些夹在加载阶段进行的动作，仍然属于连接阶段得内容，这两个阶段得开始时间仍然保持着固定的先后顺序。

验证

验证是连接阶段得第一步，这一阶段得目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。

我们知道java语言本身是相对安全的语言，通过像一些ide工具（Eclipse）已经帮助我们在编译阶段完成了验证，但是我们前面讲到Class可以通过任何途径产生，有可能通过文本编辑器之类的工具，所以在此刻校验就显得尤为重要了。

在这阶段如果验证到输入的字节流不符合Class文件格式约束，将抛出一个java.lang.VerifyError异常。

验证阶段主要包括下面四个阶段得检验：文件格式验证、元数据验证、字节码验证、符号引用验证。

1）文件格式验证

这一阶段要验证字节流是否符合Class文件格式的规范（是否以模数开头，主次版本号是否在在当前虚拟机处理范围等等），并且能被当前版本的虚拟机处理。

该阶段验证的主要目的是保证输入的字节流能正确的解析并存储于方法区内，格式上符合描述一个java类型信息的要求。这阶段得验证是基于二进制字节流进行的，只有通过了这个阶段得验证后，字节流才会进入内存的方法区中进行存储。

2）元数据验证

对字节码描述的信息进行语义分析（是否有父类，是不是抽象类等等），以保证其描述信息符合java语言规范的要求。

3）字节码验证

这一阶段是整个验证过程中最复杂的，主要目的是通过数据流和控制流分析，确保程序语义是合法的、符合逻辑的。这个阶段将对类的方法进行校验分析，保证被校验类的方法在运行时不会做出危害虚拟机安全的事件。

4）符号引用验证

最后一个阶段发生在虚拟机将符号引用转化为直接引用的时候，符号引用可以看做是对类自身以外（常量池中的各种符号引用）的信息进行匹配性校验。

该阶段验证的目的是确保解析动作能正常进行，如果无法通过该阶段验证，将会抛出java.lang.IncompatibleClassChangeError异常

对于虚拟机的类加载机制来说，验证阶段是一个非常重要的，但不是一定必要（因为对运行期没有影响）的阶段。如果运行的全部代码（包括自己编写的及第三方包中的代码）都已经被反复使用和验证过，那么在实施阶段就可以考虑使用-Xverify:none参数来关闭大部分的类验证措施，以缩短虚拟机加载的时间。

准备

准备阶段是正式为类变量 分配内存并设置类变量初始值的阶段，这些变量所使用的内存都将在方法区中进行分配。

注意这时候进行内存分配的仅包括类变量，而不包括实例变量，实例变量将会在对象实例化事随着对象一起分配在java堆中。其次，这里所说的初始值，通常情况下是数据类型的零值，假设一个类变量定义为：

public static int value=123;

那变量value在准备阶段过后的初始值是0而不是123，因为这时候尚未开始执行任何java方法，而把value赋值为123的pubstatic指令（读者可以自行搜索下java的字节码指令）是程序编译后，存放于类构造器<clinit>（）方法之中，所以把value赋值为123的动作将会在初始化阶段才会执行。

特殊情况：

public static final int value=123;

常量，在准备阶段就会将value赋值为123。

解析

解析阶段是虚拟机将常量池内的符号引用替换为直接引用的过程。解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符7类符号引用进行。

在这个阶段只需记住一点，虚拟机先对类进行解析，然后再对类属性及方法进行解析，在解析属性和方法时都是先解析其父类，若找到则直接返回引用，若找不到则抛出异常。

初始化

类初始化阶段是类加载过程的最后一步，到了初始化阶段，才真正开始执行类中定义的java程序代码。在准备阶段，变量已经赋过一次系统要求的初始值，而在初始化阶段，则根据程序猿通过程序制定的主观计划去初始化类变量和其他资源，或者说：初始化阶段是执行类构造器<clinit>()方法的过程.

<clinit>()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块static{}中的语句合并产生的，编译器收集的顺序是由语句在源文件中出现的顺序所决定的，静态语句块只能访问到定义在静态语句块之前的变量，定义在它之后的变量，在前面的静态语句块可以赋值，但是不能访问。如下：

public class Test {

    static

    {

        i=0;

        System.out.println(i);//这句编译器会报错：Cannot reference a field before it is defined（非法向前应用）

    }

    static int i=1;

}

那么去掉报错的那句，改成下面：

public class Test {

    static

    {

        i=0;

//      System.out.println(i);

    }

    static int i=1;

    public static void main(String args[])

    {

        System.out.println(i);

    }

}

输出结果是什么呢？当然是1啦~在准备阶段我们知道i=0，然后类初始化阶段按照顺序执行，首先执行static块中的i=0,接着执行static赋值操作i=1,最后在main方法中获取i的值为1。

<clinit>()方法与实例构造器<init>()方法不同，它不需要显示地调用父类构造器，虚拟机会保证在子类<cinit>()方法执行之前，父类的<clinit>()方法已经执行完毕。

由于父类的<clinit>()方法先执行，也就意味着父类中定义的静态语句块要优先于子类的变量赋值操作。

<clinit>()方法对于类或者接口来说并不是必需的，如果一个类中没有静态语句块，也没有对变量的赋值操作，那么编译器可以不为这个类生产<clinit>()方法。

接口中不能使用静态语句块，但仍然有变量初始化的赋值操作，因此接口与类一样都会生成<clinit>()方法。但接口与类不同的是，执行接口的<clinit>()方法不需要先执行父接口的<clinit>()方法。只有当父接口中定义的变量使用时，父接口才会初始化。另外，接口的实现类在初始化时也一样不会执行接口的<clinit>()方法。

虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确的加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的<clinit>()方法，其他线程都需要阻塞等待，直到活动线程执行<clinit>()方法完毕。如果在一个类的<clinit>()方法中有耗时很长的操作，就可能造成多个线程阻塞，在实际应用中这种阻塞往往是隐藏的。

package test;

public class DealLoopTest {

static class DeadLoopClass

    {

        static

        {

            if(true)

            {

System.out.println(Thread.currentThread()+"init DeadLoopClass");

                while(true)

                {

                }

            }

        }

    }

    public static void main(String[] args)

    {

        Runnable script =new Runnable(){

            public void run()

            {

                System.out.println(Thread.currentThread()+" start");

                DeadLoopClassdlc =new DeadLoopClass();

                System.out.println(Thread.currentThread()+" run over");

            }

        };

        Thread thread1 =new Thread(script);

        Thread thread2 =new Thread(script);

        thread1.start();

        thread2.start();

    }

}

运行结果：（即一条线程在死循环以模拟长时间操作，另一条线程在阻塞等待）

Thread[Thread-0,5,main] start

Thread[Thread-1,5,main] start

Thread[Thread-0,5,main]init DeadLoopClass

需要注意的是，其他线程虽然会被阻塞，但如果执行<clinit>()方法的那条线程退出<clinit>()方法后，其他线程唤醒之后不会再次进入<clinit>()方法。同一个类加载器下，一个类型只会初始化一次。

4.答案详解

看到这里大家是不是对开头的程序输出结果有头绪了呢？

这个是我在论坛上看到的一个问题，我觉得比较经典。
  一般对于这类问题，小伙伴们脑海中肯定浮现出这样的knowledge:

Java中赋值顺序： 
1. 父类的静态变量赋值 
2. 自身的静态变量赋值 
3. 父类成员变量赋值和父类块赋值 
4. 父类构造函数赋值 
5. 自身成员变量赋值和自身块赋值 
6. 自身构造函数赋值

好了,按照这个理论输出是什么呢？答案输出:1,2，3，a=110,b=112,4，这样正确嚒？肯定不正确啦，这里不是说上面的规则不正确，而是说不能简单的套用这个规则。
  正确的答案是：

2

3

a=110,b=0

1

4

 

这里主要的点之一：实例初始化不一定要在类初始化结束之后才开始初始化。
  类的生命周期是：加载->验证->准备->解析->初始化->使用->卸载，只有在准备阶段和初始化阶段才会涉及类变量的初始化和赋值，因此只针对这两个阶段进行分析。
  类的准备阶段需要做是为类变量分配内存并设置默认值，因此类变量st为null、b为0；（需要注意的是如果类变量是final，编译时javac将会为value生成ConstantValue属性，在准备阶段虚拟机就会根据ConstantValue的设置将变量设置为指定的值，如果这里这么定义：static final int b=112,那么在准备阶段b的值就是112，而不再是0了。）
  类的初始化阶段需要做是执行类构造器（类构造器是编译器收集所有静态语句块和类变量的赋值语句按语句在源码中的顺序合并生成类构造器，对象的构造方法是<init>()，类的构造方法是<clinit>()，可以在堆栈信息中看到），因此先执行第一条静态变量的赋值语句即st = new StaticTest ()，此时会进行对象的初始化，对象的初始化是先初始化成员变量再执行构造方法，因此设置a为110->打印2->执行构造方法(打印3,此时a已经赋值为110，但是b只是设置了默认值0，并未完成赋值动作)，等对象的初始化完成后继续执行之前的类构造器的语句，接下来就不详细说了，按照语句在源码中的顺序执行即可。 
  这里面还牵涉到一个冷知识，就是在嵌套初始化时有一个特别的逻辑。特别是内嵌的这个变量恰好是个静态成员，而且是本类的实例。 
  这会导致一个有趣的现象：“实例初始化竟然出现在静态初始化之前”。其实并没有提前，你要知道java记录初始化与否的时机。 
  看一个简化的代码，把关键问题解释清楚：

public class Test {

    public static void main(String[] args) {

        func();

    }

    static Test st = new Test();

    static void func(){}

}

根据上面的代码，有以下步骤：首先在执行此段代码时，首先由main方法的调用触发静态初始化。在初始化Test类的静态部分时，遇到st这个成员。但凑巧这个变量引用的是本类的实例。那么问题来了，此时静态初始化过程还没完成就要初始化实例部分了。是这样么？

从人的角度是的。但从java的角度，一旦开始初始化静态部分，无论是否完成，后续都不会再重新触发静态初始化流程了。

因此在实例化st变量时，实际上是把实例初始化嵌入到了静态初始化流程中，这就导致了实例初始化完全至于静态初始化之前。这也是导致a有值b没值的原因。

最后再考虑到文本顺序，结果就显而易见了。

 

参考文献：

《深入理解java虚拟机》 周志明

《java虚拟机规范》java se7版 （美）林霍尔姆等著

http://blog.csdn.net/u013256816/article/details/50837863  朱小厮