Java类加载机制

Java类加载机制

虚拟机将class文件加载到内存，并对数据进行解析，校验，初始化的过程。

• 装载：找到指定的class文件->获取此类的二进制字节流->Java堆中产生相应的Class对象
• 链接：将二进制数据加载到内存->

校验：检查数据是否正确
准备：给类的静态变量分配内存空间，设置初始值
解析：将符号引用转成直接引用  

• 类初始化：cinit()（并不是类被加载之后就会进行类初始化,这是个误区），以下情况才会执行cinit():

遇到 new、getstatic、putstatic或invokestatic指令时，如果类还没有初始化过，就触发初始化。（即 new 实例化对象，操作静态变量、调用静态方法的时候。被final修饰的静态变量除外，因其在编译期间就会把结果放入常量池）。
使用reflect包方法对类进行反射调用。
初始化一个类的时候，会先初始化其未被初始化过的父类。
用户所指定要执行的包含Main方法的类。

延伸

类加载器

• Bootstrap ClassLoader：加载存放于JAVA_HOME\lib目录中的指定文件名的jar文件。路径参数可以用-Xbootclasspath来指定。这个类加载器无法被java程序直接引用。
• Extension ClassLoader：加载存放于JAVA_HOME\lib\ext目录下的。或者被java.ext.dirs系统变量所指定的目录。开发者可以直接使用该类加载器。
• Application ClassLoader：加载用户类目录指定的类库，开发者可以直接使用。

拼爹的工作模式

所有的类加载器在收到加载类的请求时，都会把这个任务委托给其父类去执行，所以所有的请求都会被传到顶层，当父类无法完成加载请求（类不在所指定的范围中），子类才会尝试自己去加载。

protected Class<?> loadClass(String name, boolean resolve)
    throws ClassNotFoundException
{
    synchronized (getClassLoadingLock(name)) {
        // First, check if the class has already been loaded
        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;
    }
}

cinit和init

一般情况下cinit先于init。所以初始化的顺序应该是：

1. 父类静态变量初始化 
2. 父类静态语句块 
3. 子类静态变量初始化 
4. 子类静态语句块 
5. 父类变量初始化 
6. 父类语句块 
7. 父类构造函数 
8. 子类变量初始化 
9. 子类语句块 
10.子类构造函数

为什么说是一般情况下呢？下面有个例子挺有意思，可以分享一下：

public class StaticTest {

    public static void main(String[] args) {
        staticFunction();
    }

    static StaticTest st = 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;

}

先不执行程序，可以先猜猜运行的结果

2
3
a=110,b=0
1
4

为什么会这样呢?

接下来解释一下：
首先这个方法含有main方法，所以在执行main方法之前会先初始化这个类，这个类没有父类，所以先执行静态变量的初始化。即

static StaticTest st = new StaticTest();

因为cinit只会执行一次，所以new 的时候不会再执行了，即便它还没执行结束。这时，cinit就会等待init方法的执行返回。执行init方法：

  int a=110;

  {
        System.out.println("2");
    }

 StaticTest() {
        System.out.println("3");
        System.out.println("a="+a+",b="+b);
    }

这里就打印了2，3，a=110，b=0.因为b还没有被初始化。
等到init方法执行结束，就会继续执行cinit方法，

 static int b =112;

 static {
        System.out.println("1");
    }

这里又打印出了1.
等初始话都结束后，才会调用staticFunction()方法打印4.

以上，学习笔记。如有错误，欢迎指出。