虚拟机加载机制

java中的类并不是在运行或编译时就被初始化的，而是在运行的过程中需要的时候才被初始化，一个类的生命周期包括下面7个阶段：

加载->验证->准备->解析->初始化->使用->卸载

其中，加载、验证、准备、初始化和卸载这5个阶段的顺序是确定的，“解析”可能在初始化之前或之后进行，“使用”应该也能在初始化之前或之后进行。

---

类何时被初始化

一个类当且仅当在下面4种情况之一发生时才会被初始化：

1、遇到new、getstatic、putstatic或invokestatic这4条字节码指令时，最常见的java代码场景是：使用new实例化对象时、读取或设置一个类的静态字段（被final修饰、在编译期已经放入常量池的静态字段除外，也就是说，读取或设置该字段不会导致类的初始化，所以使用可能才初始化之前）时，以及调用一个类的静态方法时。

2、虚拟机启动时，用户需要指定一个包含main函数的主类，这个主类会先被初始化

3、初始化一个类时，如果发现其父类还没初始化，则先初始化其父类

4、使用java.lang.reflect包的方法对类进行反射调用时

例子：

1、static块或static变量（除了final修饰以外）不会在程序启动就执行的，它们要等到类初始化时才被执行：

class A{

   static{

      System.out.println("I am A!");

   }

}

publicclass test1 {

    publicstaticvoid main(String[]args){}

}

没有任何输出，A类没有被初始化

2、

class SuperClass{

   static{

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

   }

}

class SubClass extends SuperClass{

   static{

      System.out.println("SubClass init!");

   }

}

publicclass test1 {

    publicstaticvoid main(String[]args){

       SubClass subClass = new SubClass();

    }

}

输出：

SuperClass init!

SubClass init!

两个类都被初始化了

3、

class SuperClass{

   static{

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

   }

}

class SubClass extends SuperClass{

   static{

      System.out.println("SubClass init!");

   }

}

publicclass test1 {

    publicstaticvoid main(String[]args){

       System.out.println(SubClass.class);

    }

}

输出：class SubClass

两个类都没有被初始化

4、

class SuperClass{

   static{

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

   }

   public static int value = 10;//该变量会放入方法区

}

class SubClass extends SuperClass{

   static{

      System.out.println("SubClass init!");

   }

}

publicclass test1 {

    public static void main(String[]args){

       System.out.println(SubClass.value);

    }

}

输出：

SuperClass init!

10

SuperClass被初始化，SubClass没有被初始化

5、

class SuperClass{

   static{

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

   }

   publicstaticfinalintfinalValue = 20;//该变量会放入方法区中的常量池里

}

class SubClass extends SuperClass{

   static{

      System.out.println("SubClass init!");

   }

}

publicclass test1 {

    publicstaticvoid main(String[]args){

       System.out.println(SubClass.finalValue);

    }

}

输出：20

两个类都没有被初始化，因为finalValue这个变量在程序启动时就已经放到常量池中，以后直接从常量池中取出便可

6、

class SuperClass{

   static{

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

   }

}

class SubClass extends SuperClass{

   static{

      System.out.println("SubClass init!");

   }

}

publicclass test1 {

    publicstaticvoid main(String[]args){

       SuperClass[]sup = new SuperClass[5];

       SubClass[]sub = new SubClass[5];

    }

}

没有任何输出，直到执行sup[i] = new SuperClass()时SuperClass才被初始化，静态代码块只执行一次，也就是说，后面再加上下面语句：

       sup[0] = new SuperClass();

       sub[0] = new SubClass();

打印结果为：

SuperClass init!

SubClass init!

注意：

Java中，创建元素类型为类类型的数组不会导致类的构造函数被调用，也不会导致类的初始化，但C++会导致构造函数被调用：

#include<iostream>

usingnamespace std;

classA

{

public:

    A()

    {

        cout << "A构造函数被调用" << endl;

    }

};

void main()

{

    A a[3];

}

输出：

A构造函数被调用

A构造函数被调用

A构造函数被调用

内部类不会因外部类初始化而被初始化

publicclass test1 {

   static{

      System.out.println("The main class is inited!");

   }

   staticclass innerClass{

      static{

         System.out.println("The innerClass is inited!");

      }

   }

    publicstaticvoid main(String[]args){

    }

}

输出：The main class is inited!

可见innerClass不会被初始化

publicclass test1 {

   staticclass innerClass{

      staticintA = 0;

      static{

         System.out.println("The innerClass is inited!");

      }

   }

    publicstaticvoid main(String[]args){

       System.out.println(innerClass.A);

    }

}

输出：

The innerClass is inited!

0

publicclass test1 {

   staticclass Parent{

      publicstaticintA = 0;

      static{

         System.out.println("Parent is inited!");

      }

   }

   staticclass Child extends Parent{

      static{

         System.out.println("Child is inited!");

      }

   }

    publicstaticvoid main(String[]args){

       System.out.println(Child.A);

    }

}

输出：

Parent is inited!

0

可见内部类的初始化也要满足前面提到的初始化4个条件

publicclass test1 {

   staticclass Parent{

      publicstaticintA = 0;

      static{

         A = 2;

      }

   }

   staticclass Child extends Parent{

      publicstaticintB = A;

   }

    publicstaticvoid main(String[]args){

       System.out.println(Child.B);

    }

}

输出：2

初始化执行顺序

类初始化是类加载过程的最后一步，类初始化时会执行静态变量初始化、静态代码块。

注意：构造函数不一定被调用！！因为构造函数需要显式调用的。

总的执行顺序：

总是先执行静态代码部分再执行构造函数（如果会执行的话），最后才是普通代码块：

例子：

publicclass Test{

   public Test(){

      System.out.println("构造函数");

   }

   static{

      System.out.println("static块");

   }

   publicstaticvoid main(String []args){

      Test test = new Test();

   }

}

输出：

static块

构造函数

public class Person {

    static{

        System.out.println("person static");

    }

    public Person(){

        System.out.println("person structor");

    }

} 

public class Test extends Person{

    static{

        System.out.println("test static");

    }

    public Test(){

        System.out.println("test constructor");

    }

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

}

输出：

person static

test static

上面例子如果在main函数中加上下面语句：

new Test();

则输出：

person static

test static

person structor

test constructor

静态部分的顺序：

按照代码的顺序执行，前面的不能访问后面声明的静态变量，但可以对后面声明的静态变量赋值（普通方法对后面的非静态变量既不能访问也不能赋值）

例子：

publicclass Test{

   static{

      n = 2;//如果是System.out.println(n);则报错，因为n还没定义

   }

   publicstaticintn = 1;

   publicstaticvoid main(String []args){

      System.out.println(Test.n);

   }

}

输出1，如果两个静态部分位置交换，则输出2

易错

public class Test2 {

    private String baseName = "base";

    public Test2() {

        callName();

    }

    public void callName() {

        System.out.println(baseName);

    }

    static class Sub extends Test2 {

        private String baseName = "sub";

        public void callName() {

            System.out.println(baseName);

        }

    }

    public static void main(String[] args) {

        new Sub();

    }

}

上面代码输出：null

new Sub();在创造派生类的过程中首先创建基类对象，然后才能创建派生类。创建基类即默认调用Test2()方法，在方法中调用callName()方法，由于派生类中存在此方法，则被调用的callName()方法是派生类中的方法，此时派生类还未构造，所以变量baseName的值为null。如果把Sub类中的callName方法删掉，则输出base。

JVM会保证一个类的初始化被加锁

如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的<clinit>()方法，<clinit>()方法指的是全部的static成员及static块，其它线程都需要阻塞等待，所以，如果一个类的初始化耗时比较长的话，会影响到别的线程的执行。

public class Person {

    static {

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

    }

    static {

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

    }

    static {

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

    }

    .......

} 

public class Test {

    public static void main(String[] args) {

        Runnable runnable = new Runnable() {

            @Override

            public void run() {

                new Person();

            }

        };

        Thread thread1 =new Thread(runnable);

        Thread thread2 = new Thread(runnable);

        thread1.start();

        thread2.start();

        System.out.println("main finish");

    }

}

输出：

main finish

1.....

1.....

1.....

......

有多个线程导致类的初始化，但只有一个线程真正使得类被初始化，其它线程一直等待直到类被初始化完成。

public class Person {

    static {

        System.out.println("static...");

        if(true){

            while(true){}

        }

    }

} 

public class Test {

    public static void main(String[] args) {

        Runnable runnable = new Runnable() {

            @Override

            public void run() {

                new Person();

                System.out.println("thread finish");

            }

        };

        Thread thread1 =new Thread(runnable);

        Thread thread2 = new Thread(runnable);

        thread1.start();

        thread2.start();

        System.out.println("main finish");

    }

}

输出：

main finish

static...

可见另一个线程也被阻塞。

---

类何时被卸载

这里说的是类的卸载，而不是类对象或实例的内存回收，java中采用的是双亲委派机制实现类的加载，同一个加载器对一个类只会加载一次，加载之后可以创建多个实例，如果希望对一个类加载多次，则需要实现自定义的加载器，然后破坏双亲委派机制。类的实例的回收也就是对象的回收，根据根搜索如果没找到一条与之连通路径，则便可标记为垃圾，便可以等待被回收，但类本身什么时候才可以被回收呢？首先判断一个类是否是“无用的类”要同时满足下面3个条件：

1、该类的所有实例都已经被回收；

2、加载该类的ClassLoader已经被回收，这里应该是说ClassLoader的实例，如果是ClassLoader被卸载，则加载该ClassLoader的ClassLoader也要被卸载，依次类推，直至jvm的系统类加载器，这样便无法回收类；

3、该类对应的java.lang.Class对象没有在任何地方被引用，也就是说无法在任何地方通过反射来访问该类；

满足上面3个条件仅仅说明虚拟机“可以”对该类进行回收，并不说明一定会被回收，具体什么时候回收与虚拟机的实现有关，通常为了让加载的类可以被卸载，需要自定义ClassLoader，所以很多使用反射、动态代理、CGLib等bytecode的框架以及OSGI都频繁使用自定义类加载器。