JVM类加载过程原理/实例

简介
        本文介绍Java的类加载过程&＃xff0c;有实例。

基础
加载过程

加载&＃61;> 链接&＃xff08;验证&＃43;准备&＃43;解析&＃xff09;&＃61;> 初始化&＃61;> 使用&＃61;> 卸载

加载
通过一个类的全限定名获取定义此类的二进制字节流。
将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。
在内存&＃xff08;不一定在堆&＃xff0c;对于HotSpot在方法区&＃xff09;中生成一个代表这个类的java.lang.Class对象&＃xff0c;作为方法区这个类的各种数据的访问入口。
链接
验证&＃xff1a;检查载入的class文件数据的正确性
准备&＃xff1a;给类变量&＃xff08;静态变量&＃xff09;分配内存&＃xff08;方法区&＃xff09;并设置为零值&＃xff08;0、false、null等&＃xff09;。
           例外&＃xff1a;static final类型。static final int a &＃61; 12; 在准备阶段就将a赋值为12。
解析&＃xff08;可选&＃xff09;&＃xff1a;将常量池内的符号引用替换成直接引用
初始化&＃xff1a;初始化类变量&＃xff08;静态变量&＃xff09;、执行静态语句块
执行类变量&＃xff08;静态变量&＃xff09;的赋值动作和静态语句块&＃xff08;赋值与语句块是按定义的顺序进行的&＃xff09;。优先级&＃xff1a;静态、父类、子类&＃xff09;
注意&＃xff1a;初始化是操作类变量&＃xff08;也就是Class的变量&＃xff09;&＃xff0c;不是对象的变量。
使用&＃xff1a;以new一个对象为例
若是第一次创建 Dog 对象&＃xff08;对象所属的类没有加载到内存中&＃xff09;则先执行上面的初始化操作。
在堆上为 Dog 对象&＃xff08;包括实例变量&＃xff09;分配空间&＃xff0c;所有属性都设成默认值(数字为 0&＃xff0c;字符为 null&＃xff0c;布尔为 false&＃xff0c;引用被设成 null&＃xff09;
初始化实例&＃xff1a;给实例变量赋值、执行初始化语句块
执行构造函数检查是否有父类&＃xff0c;如果有父类会先调用父类的构造函数
执行构造函数。
虚拟机规范严格规定&＃xff1a; 有且只有 5 种情况 必须立即对类进行初始化&＃xff08;加载、验证、准备自然需要在之前执行&＃xff09;&＃xff1a;

遇到 new 、getstatic、putstatic 或 invokestatic 这 4 条字节码指令时&＃xff0c;若没有对类进行初始化&＃xff0c;则要先触发其初始化。
这4个指令含义是&＃xff1a;使用 new 新建一个 Java 对象&＃xff0c;访问或者设置一个类的静态字段&＃xff0c;访问一个类的静态方法。大数据培训
使用 java.lang.reflect 包的方法对类进行反射调用的时候&＃xff0c;如果类没有进行初始化&＃xff0c;则需要先触发其初始化。
当初始化一个类的时候&＃xff0c;如果发现其父类还没有进行过初始化&＃xff0c;则需要先触发其父类的初始化。
当虚拟机启动的时候&＃xff0c;用户需要指定一个需要执行的主类&＃xff08;包含 main 方法的那个类&＃xff09;&＃xff0c;虚拟机会先初始化这个类。
当使用 JDK 1.7 的动态语言支持时&＃xff0c;如果一个 java.lang.invoke.MethodHandle 实例最后的解析结果 REF_getStatic、REF_putStatic、REF_invokeStatic 的方法句柄&＃xff0c;并且这个方法句柄对应的类没有进行过初始化&＃xff0c;则需要先触发其初始化。
验证类加载

package org.example.a;

class Tester1 {
//如果静态变量的赋值放到静态代码块之后&＃xff0c;则会报错&＃xff1a;非法向前引用
static int i &＃61; 2;

static{
System.out.println("初始化类&＃xff1a;i &＃61; " &＃43; i);
    }

Tester1(){
System.out.println("构造方法");
    }

public void test(){
System.out.println("test 方法");
    }
}

public class Demo {

public static void main(String[] args) throws ClassNotFoundException {
ClassLoader cl &＃61; ClassLoader.getSystemClassLoader();
//装载类
cl.loadClass("org.example.a.Tester1");
System.out.println("装载类");
//初始化类
Class.forName("org.example.a.Tester1");
System.out.println("初始化结束");
Tester1 test &＃61; new Tester1();
test.test();
    }
}

运行结果

装载类
初始化类&＃xff1a;i &＃61; 2
初始化结束
构造方法
test 方法

问答
为什么静态方法不能调用非静态方法和变量&＃xff1f;

       静态方法是属于类的&＃xff0c;在类加载的时候就会分配内存&＃xff0c;可以通过类名直接去访问。非静态成员&＃xff08;变量和方法&＃xff09;属于类的对象&＃xff0c;只有该对象实例化之后才存在&＃xff0c;然后通过类的对象去访问。

       加载阶段的第二步&＃xff08;&＃xff08;2&＃xff09;将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构&＃xff09;会将所有static修饰的内容&＃xff08;包括静态属性、静态代码块、静态方法等&＃xff09;转为方法区的运行时数据结构&＃xff0c;但此时非静态的方法和变量根本没经过初始化&＃xff08;没有内存&＃xff09;&＃xff0c;所以会失败。

实例验证
类初始化顺序
package org.example.a;

class Test{
int a &＃61; instanceMethod();
static int b &＃61; staticMethod();

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

    {
System.out.println("instance block");
    }

public Test(){
System.out.println("constructor");
    }

public int instanceMethod(){
System.out.println("instance method");
return 2;
    }

public static int staticMethod(){
System.out.println("static method");
return 2;
    }
}

public class Demo {
public static void main(String[] args) {
Test child &＃61; new Test();
    }
}

运行结果

static method
static block
instance method
instance block
constructor

手动装载/初始化
package org.example.a;

class Test{
int a &＃61; instanceMethod();
static int b &＃61; staticMethod();

static {
System.out.println("static block");
    }
    {
System.out.println("instance block");
    }
public Test(){
System.out.println("constructor");
    }

public int instanceMethod(){
System.out.println("instance method");
return 2;
    }

public static int staticMethod(){
System.out.println("static method");
return 2;
    }
}

public class Demo {
public static void main(String[] args) {
ClassLoader cl &＃61; ClassLoader.getSystemClassLoader();
try {
//装载类
cl.loadClass("org.example.a.Test");
System.out.println("装载类结束");
//初始化类
Class.forName("org.example.a.Test");
System.out.println("初始化结束");
Test test &＃61; new Test();
test.instanceMethod();
        } catch (ClassNotFoundException e) {
e.printStackTrace();
        }
    }
}

执行结果

装载类结束
static method
static block
初始化结束
instance method
instance block
constructor
instance method

静态域的访问
访问类或接口的静态域时&＃xff0c;只有真正声明这个域的类或接口才会被初始化

package org.example.a;

class B {
static int value &＃61; 100;
static {
System.out.println("Class B is initialized."); //输出
    }
}
class A extends B {
static {
System.out.println("Class A is initialized."); //不会输出
    }
}

public class Demo {
public static void main(String[] args) {
System.out.println(A.value); //输出100
    }
}

执行结果

Class B is initialized.
100

线程安全
简介

Java类的加载和初始化过程都是线程安全的。具体原因如下&＃xff1a;

加载
类加载整个过程是线程安全的&＃xff0c;因为loadClass方法内有synchronized。
初始化
虚拟机会保证一个类的()方法在多线程环境中被正确地加锁、同步&＃xff0c;如果多个线程同时去初始化一个类&＃xff0c;那么只会有一个线程去执行这个类的()方法&＃xff0c;其他线程都需要阻塞等待&＃xff0c;直到活动线程执行()方法完毕。
总结

        类的静态资源都是线程安全的&＃xff0c;而且是单例的。因此&＃xff0c;在写单例模式时&＃xff0c;经常会使用static标记实例变量。比如&＃xff1a;

public class Singleton {
private static Singleton instance &＃61; new Singleton();

private Singleton() {
    }

public static Singleton getInstance() {
return instance;
    }
}

加载源码

见java.lang.ClassLoader#loadClass&＃xff1a;

下边方法前边有个注释&＃xff1a;

Unless overridden, this method synchronizes on the result of method during the entire class loading process.

//除非被重写&＃xff0c;否则整个装载过程中是线程安全的。注意&＃xff1a;本处装载是装载、链接、初始化的装载&＃xff0c;而不是整个加载流程

protected Class loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
// First, check if the class has already been loaded
Class c &＃61; findLoadedClass(name);
if (c &＃61;&＃61; null) {
long t0 &＃61; System.nanoTime();
try {
if (parent !&＃61; null) {
c &＃61; parent.loadClass(name, false);
        } else {
c &＃61; findBootstrapClassOrNull(name);
        }
      } catch (ClassNotFoundException e) {
// ClassNotFoundException thrown if class not found
// from the non-null parent class loader
      }

if (c &＃61;&＃61; null) {
// If still not found, then invoke findClass in order
// to find the class.
long t1 &＃61; System.nanoTime();
c &＃61; 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;
  }
}

Class对象
基础
其他网址

《深入理解Java虚拟机 JVM高级特性与最佳实践 第2版》&＃61;> 第7章 虚拟机类加载机制

代码实例

        一旦类被加载了到了内存中&＃xff0c;不论通过哪种方式获得该类的Class对象&＃xff0c;它们返回的都是指向同一个java堆地址&＃xff08;对于HotSpot是方法区&＃xff09;上的Class引用。

package org.test.a;

class Cat{
static {
System.out.println("static cat");
    }
}

public class Demo {
public static void main(String[] args) throws ClassNotFoundException {
Class c1 &＃61; Cat.class;
Class c2 &＃61; new Cat().getClass();
Class c3 &＃61; new Cat().getClass();
Class c4 &＃61; Class.forName("org.test.a.Cat");
System.out.println(c1 &＃61;&＃61; c2);
System.out.println(c2 &＃61;&＃61; c3);
System.out.println(c3 &＃61;&＃61; c4);
    }
}

输出结果

static cat
true
true
true

分析

        内存的字节码块就是完整的把整个类装到了内存。使用的主要步骤如下&＃xff1a;

当一个ClassLoder启动的时候&＃xff0c;ClassLoader生存在jvm中的堆。
ClassLoder去主机硬盘上将A.class装载到jvm的方法区。
new A()时&＃xff1a;虚拟机使用方法区中的字节文件在堆内存生成了一个A字节码的对象
然后A字节码这个内存文件有两个引用&＃xff1a;一个指向A的class对象&＃xff0c;一个指向加载自己的classLoader

静态内部类的加载时机
说明

        只有当我们有对类的引用的时候&＃xff0c;才会将类初始化。比如以下情况

new一个非静态类的对象
访问静态类的成员(包括方法和属性)
        new一个外部类的时候&＃xff0c;加载阶段会扫描static修饰的东西&＃xff0c;初始化阶段只会执行static修饰的属性的赋值以及static代码块。利用这个特性&＃xff0c;可以做基于静态内部类的单例模式&＃xff1a;​​​​

测试

登录后复制
package org.example.a;

class OuterClass {
static {
System.out.println("OuterClass static");
    }
public static class InnerClass {
static int a &＃61; 1;
static{
System.out.println("InnerClass static");
        }

static void innerMethod(){
System.out.println("innerMethod");
        }
    }
}

public class Demo {
public static void main(String[] args) {
//OuterClass outerClass &＃61; new OuterClass();
//OuterClass.InnerClass.a &＃61; 2;
//OuterClass.InnerClass.innerMethod();
    }
}

只放开第一个测试的执行结果

OuterClass static

只放开第二个测试的执行结果

InnerClass static 

只放开第三个测试的执行结果

InnerClass static
innerMethod