深入理解jvm的类加载机制

一、类的生命周期

java程序使用某个类时，必须按照以下顺序执行：

（1）加载：查找并加载类的二进制数据；

（2）连接：包括验证、准备和解析类的二进制；

• 验证：确保加载类的正确性；
• 准备：为类的静态变量分配内存，并将其初始化为默认值；
• 解析：把类中的符号引用转为直接引用

（3）初始化：给类的静态变量赋初始值

二、类的加载

1、什么是类的加载？

类的加载指的是将类的.class文件中的二进制数据读入内存中,将其放在运行时数据区域的方法区内,然后在堆中创建java.lang.Class对象,用来封装类在方法区的数据结构.只有java虚拟机才会创建class对象。

2、什么时候对类进行加载呢？

Java虚拟机有预加载功能。类加载器并不需要等到某个类被”首次主动使用”时再加载它,JVM规范规定JVM可以预测加载某一个类，如果这个类出错，但是应用程序没有调用这个类， JVM也不会报错；如果调用这个类的话，JVM才会报错，（LinkAgeError错误)。其实就是一句话，Java虚拟机有预加载功能。

3、类加载器

类的加载是由类加载器完成，可分为两种：

1、java虚拟机自带的加载器，启动类加载器、扩展类加载器和应用加载器。

2、用户自定义的类加载器，需要继承java.lang.ClassLoader类。

启动类加载器(Bootstrap ClassLoader):
　　这个类加载器负责将<JAVA_HOME>\lib目录下的类库加载到虚拟机内存中,用来加载java的核心库,此类加载器并不继承于java.lang.ClassLoader,不能被java程序直接调用,代码是使用C++编写的.是虚拟机自身的一部分.
扩展类加载器(Extendsion ClassLoader):
　　这个类加载器负责加载<JAVA_HOME>\lib\ext目录下的类库,用来加载java的扩展库,开发者可以直接使用这个类加载器.
应用程序类加载器(Application ClassLoader):
这个类加载器负责加载用户类路径(CLASSPATH)下的类库,一般我们编写的java类都是由这个类加载器加载,这个类加载器是CLassLoader中的getSystemClassLoader()方法的返回值,所以也称为系统类加载器.一般情况下这就是系统默认的类加载器.

4、类加载的双亲委派机制

类的加载过程采用双亲委派机制，更好的保证了Java平台的安全（此机制下，用户自定义的类加载器不可能加载应该由父类加载器加载的可靠类，从而防止不可靠甚至恶意的代码代替由父类加载器加载加载的可靠代码）。除了java虚拟机自带的启动类加载器以外，其余的类加载器都有且只有一个父加载器。

比如A类的加载器是AppClassLoader(其实我们自己写的类的加载器都是AppClassLoader)，AppClassLoader不会自己去加载类，而会委ExtClassLoader进行加载，那么到了ExtClassLoader类加载器的时候，它也不会自己去加载，而是委托BootStrap类加载器进行加载，就这样一层一层往上委托，如果Bootstrap类加载器无法进行加载的话，再一层层往下走，如果加载成功，则层层返回，到底层都不能加载，则抛出ClassNotFoundException异常。

三、类的连接

1、类的验证

验证阶段主要做了以下工作
-将已经读入到内存类的二进制数据合并到虚拟机运行时环境中去。
-类文件结构检查:格式符合jvm规范

-语义检查:符合java语言规范,final类没有子类,final类型方法没有被覆盖
-字节码验证:确保字节码可以安全的被java虚拟机执行.
-二进制兼容性检查:确保互相引用的类的一致性.如A类的a方法会调用B类的b方法.那么java虚拟机在验证A类的时候会检查B类的b方法是否存在并检查版本兼容性.因为有可能A类是由jdk1.7编译的，而B类是由1.8编译的。那根据向下兼容的性质，A类引用B类可能会出错，注意是可能。

2、类的准备

java虚拟机为类的静态变量分配内存并赋予默认的初始值.如int分配4个字节并赋值为0,long分配8字节并赋值为0;

[java] view plain copy

print ?

1. public class Sample {     
2.     public static int a;  
3.     public static long b;  
4.     static{  
5.         b=2;  
6.     }     
7. }  

public class Sample {    
    public static int a;
    public static long b;
    static{
        b=2;
    }   
}

3、类的解析

解析阶段主要是将符号引用转化为直接引用的过程。比如 A类中的a方法引用了B类中的b方法，那么它会找到B类的b方法的内存地址，将符号引用替换为直接引用(内存地址)。

四、类的初始化

1、类的初始化时机：

java虚拟机在每个类或接口被 “ 首次主动使用 ”时，才初始化他们。那什么是“主动使用”呢？

主动初始化的6种方式
(1)创建对象的实例：我们new对象的时候，会引发类的初始化，前提是这个类没有被初始化。
(2)调用类的静态属性或者为静态属性赋值
(3)调用类的静态方法
(4)通过class文件反射创建对象
(5)初始化一个类的子类：使用子类的时候先初始化父类
(6)java虚拟机启动时被标记为启动类的类：就是我们的main方法所在的类
只有上面6种情况才是主动使用，也只有上面六种情况的发生才会引发类的初始化。

同时我们需要注意下面几个Tips:
1)在同一个类加载器下面只能初始化类一次,如果已经初始化了就不必要初始化了.
这里多说一点，为什么只初始化一次呢？因为我们上面讲到过类加载的最终结果就是在堆中存有唯一一个Class对象，我们通过Class对象找到类的相关信息。唯一一个Class对象说明了类只需要初始化一次即可，如果再次初始化就会出现多个Class对象，这样和唯一相违背了。
2)在编译的时候能确定下来的静态变量(编译常量),不会对类进行初始化;
3)在编译时无法确定下来的静态变量(运行时常量),会对类进行初始化;
4)如果这个类没有被加载和连接的话,那就需要进行加载和连接
5)如果这个类有父类并且这个父类没有被初始化,则先初始化父类.
6)如果类中存在初始化语句,依次执行初始化语句.

[java] view plain copy

print ?

1. public class Test1 {  
2.   public static void main(String args[]){  
3.     System.out.println(FinalTest.x);  
4.   }  
5. }  
6.   
7. class FinalTest{  
8.   public static final int x =6/3;//final关键字修饰的是常量  
9.   static {  
10.       System.out.println(”FinalTest static block”);  
11.   }  
12. }  

public class Test1 {
  public static void main(String args[]){
    System.out.println(FinalTest.x);
  }
}

class FinalTest{
  public static final int x =6/3;//final关键字修饰的是常量
  static {
      System.out.println("FinalTest static block");
  }
}

[java] view plain copy

print ?

1. public class Test2 {  
2.     public static void main(String args[]){  
3.         System.out.println(FinalTest2.x);  
4.     }  
5. }  
6. class FinalTest2{  
7.   
8. public static final int x =new Random().nextInt(100);//final关键字修饰的是常量  
9. static {  
10.     System.out.println(”FinalTest2 static block”);  
11. }  
12. }  

public class Test2 {
    public static void main(String args[]){
        System.out.println(FinalTest2.x);
    }
}
class FinalTest2{

public static final int x =new Random().nextInt(100);//final关键字修饰的是常量
static {
    System.out.println("FinalTest2 static block");
}
}

第一个输出的是
2
第二个输出的是
FinalTest2 static block
61（随机数）
为何会出现这样的结果呢？
参考上面的Tips2和Tips3，第一个能够在编译时期确定的，叫做编译常量；第二个是运行时才能确定下来的，叫做运行时常量。编译常量不会引起类的初始化，而运行常量就会进行类的初始化，所有会输出静态代码块。
那么将第一个例子的final去掉之后呢？输出又是什么呢？
这就是对类的首次主动使用，引用类的静态变量，输出的当然是：
FinalTest static block
2

2、类的初始化顺序

详情见另一篇文章 类的初始化顺序

五、结束JVM进程的几种方式

(1) 执行System.exit()
(2) 程序正常结束
(3) 程序抛出异常,一直向上抛出没处理
(4) 操作系统异常,导致JVM退出

六、练习回顾

[java] view plain copy

print ?

1. public class Singleton {  
2. private static Singleton singleton = new Singleton();  
3. public static int counter1;  
4. public static int counter2 = 0;  
5.   
6. private Singleton() {  
7.     counter1++;  
8.     counter2++;  
9. }  
10.   
11. public static Singleton getSingleton() {  
12.     return singleton;  
13. }  
14.   
15. }  

public class Singleton {
private static Singleton singleton = new Singleton();
public static int counter1;
public static int counter2 = 0;

private Singleton() {
    counter1++;
    counter2++;
}

public static Singleton getSingleton() {
    return singleton;
}

}

[java] view plain copy

print ?

1. public class TestSingleton {  
2. public static void main(String args[]){  
3.     Singleton singleton = Singleton.getSingleton();  
4.     System.out.println(”counter1=”+singleton.counter1);  
5.     System.out.println(”counter2=”+singleton.counter2);  
6.   
7. }  
8. }  

public class TestSingleton {
public static void main(String args[]){
    Singleton singleton = Singleton.getSingleton();
    System.out.println("counter1="+singleton.counter1);
    System.out.println("counter2="+singleton.counter2);

}
}

输出是：
counter1=1
counter2=0
why？我们一步一步分析：

1 执行TestSingleton第一句的时候，因为我们没有对Singleton类进行加载和连接，所以我们首先需要对它进行加载和连接操作。在连接阶-准备阶段，我们要讲给静态变量赋予默认初始值。
singleton =null
counter1 =0
counter2 =0
2 加载和连接完毕之后，我们再进行初始化工作。初始化工作是从上往下依次执行的，注意这个时候还没有调用Singleton.getSingleton();
首先 singleton = new Singleton();这样会执行构造方法内部逻辑，进行++；此时counter1=1，counter2 =1 ；
接下来再看第二个静态属性counter1，我们并没有对它进行初始化，所以它就没办法进行初始化工作了；
第三个属性counter2我们初始化为0，因此此时的counter2 =0 ；
3 初始化完毕之后我们就要调用静态方法Singleton.getSingleton(); 我们知道返回的singleton已经初始化了。
那么输出的内容也就理所当然的是1和0了。

那么我们接下来改变一下代码顺序，将

[java] view plain copy

print ?

1. public static int counter1;  
2. public static int counter2 = 0;  
3. private static Singleton singleton = new Singleton();  

 public static int counter1;
 public static int counter2 = 0;
 private static Singleton singleton = new Singleton();

输出结果是

counter1=1
counter2=1
你会分析了吗？


参考：

http://www.jianshu.com/p/b6547abd0706

http://www.jianshu.com/p/8c8d6cba1f8e