1.4 jvm 知识点汇总 概括

1、Java虚拟机结束生命周期的情况：

1）执行了System.exit()方法
2）程序正常执行结束
3）程序执行过程中遇到了异常或者错误而终止
4）操作系统出现错误而导致Java虚拟机进行终止


2、class.forName 和 classLoader.loadClass() 方法的区别：


Class的装载分了三个阶段，loading，linking和initializing，分别定义在The Java Language Specification的12.2，12.3和12.4。
Class.forName(className)实际上是调用Class.forName(className, true, this.getClass().getClassLoader())。注意第二个参数，是指Class被loading后是不是必须被初始化。
ClassLoader.loadClass(className)实际上调用的是ClassLoader.loadClass(name, false)，第二个参数指出Class是否被link。
这就是区别： Class.forName(className)装载的class已经被初始化，而ClassLoader.loadClass(className)装载的class不连接，不初始化。
一般情况下，这两个方法效果一样，都能装载Class。但如果程序依赖于Class是否被初始化，就必须用Class.forName(name)了。
例如，在JDBC编程中，常看到这样的用法，Class.forName("com.mysql.jdbc.Driver")，如果换成了getClass().getClassLoader().loadClass("com.mysql.jdbc.Driver")，就不行。
为什么呢？打开com.mysql.jdbc.Driver的源代码看看，
//
// Register ourselves with the DriverManager
//
static {
    try {
        java.sql.DriverManager.registerDriver(new Driver());
    } catch (SQLException E) {
        throw new RuntimeException("Can't register driver!");
    }
}
原来，Driver在static块中会注册自己到java.sql.DriverManager。而static块就是在Class的初始化中被执行。所以这个地方就只能用Class.forName(className)。


3、Java程序对类的使用方式：
1）主动使用：
	访问或者设置某个类的静态变量
	调用类的静态方法
    创建类的实例
    初始化一个类的子类的时候
	反射（如 Class.forName(“com.itzhai.Test”)）
	Java虚拟机启动时被标明为启动类的类（Main Class）
2）被动使用：
	除了上述六种情况，其他使用Java类的方式都被看做是对类的被动使用，都不会导致类的初始化。
	所有的Java虚拟机实现必须在每个类或接口被Java程序“首次主动使用”时才初始化它们。


4、类的加载：
	类的加载指的是将类的.class文件中的二进制数据读入到内存中，将其放在运行时数据区的方法区内，然后在堆区创建一个java.lang.Class对象，用来封装类在方法区内的数据结构。
4.1、加载.class文件的方式：
 从本地系统中直接加载
 从网络下载.class文件
 从zip,jar等归档文件中加载.class文件
 从专有数据库中提取.class文件
 将Java源文件动态编译为.class文件


类的加载的最终产品是位于堆区中的Class对象
Class对象封装了类在方法区内的数据结构，并且向Java程序员提供了访问方法区内的数据结构的接口。


4.2、两种类型的ClassLoader类加载器：
① JVM Java虚拟机自带的类加载器：
a、根类加载器（Bootstrap）：使用C++编写，程序员无法再Java代码中获得该类
b、扩展类加载器（Extension）：使用Java代码实现
c、系统类加载器（System）/应用加载器：使用Java代码实现
② 用于自定义的类加载器：
a、java.lang.ClassLoader的子类
b、用户可以定制类的加载方式
public abstract class ClassLoader
extends Object
类加载器是负责加载类的对象。ClassLoader 类是一个抽象类。如果给定类的二进制名称，那么类加载器会试图查找或生成构成类定义的数据。一般策略是将名称转换为某个文件名，然后从文件系统读取该名称的“类文件”。
每个 Class 对象都包含一个对定义它的 ClassLoader 的引用。
数组类的 Class 对象不是由类加载器创建的，而是由 Java 运行时根据需要自动创建。数组类的类加载器由 Class.getClassLoader() 返回，该加载器与其元素类型的类加载器是相同的；如果该元素类型是基本类型，则该数组类没有类加载器。
getClassLoader
public ClassLoader getClassLoader()
返回该类的类加载器。有些实现可能使用 null 来表示引导类加载器。如果该类由引导类加载器加载，则此方法在这类实现中将返回 null。
如果存在安全管理器，并且调用者的类加载器不是 null，也不同于或是请求其类加载器的类的类加载器的祖先，则此方法通过 RuntimePermission("getClassLoader") 权限调用此安全管理器的 checkPermission 方法，以确保可以访问该类的类加载器。
如果此对象表示一个基本类型或 void，则返回 null。
返回：
加载此对象所表示的类或接口的类加载器。
抛出：
SecurityException - 如果存在安全管理器，并且 checkPermission 方法拒绝对该类类加载器的访问。
newProxyInstance
public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
                               throws IllegalArgumentException
类加载器并不需要等到某个类被“首次主动使用”时再加载它。
JVM规范允许类加载器在预料某个类将要被使用时就预先加载它，如果在预加载的过程中遇到.class文件缺失或存在错误，类加载器必须在程序首次主动使用该类时才报告LinkageError错误。如果这个类一直没有被程序主动使用，那么类加载器就不会报告错误。


5、类的连接：
类被加载后，就进入了连接阶段。连接就是将已经读入到内存的类的二进制数据合并到虚拟机的运行时环境中去。
5.1、类的验证：
类的验证的内容：
类文件的结构检查：确保类文件遵从Java类文件的固定格式。
语义检查：确保类本身符合Java语言的语法规定，比如验证final类型的类没有子类，以及final类型的方法没有被覆盖。
字节码验证：确保字节码流可以被Java虚拟机安全的执行。字节码流代码Java方法（包括静态方法和实例方法），它是被称作操作码的单字节指令组成的序列，每一个操作码后都跟着一个或多个操作数。字节码验证步骤会检查每个操作码是否合法，即是否有着合法的操作数。
二进制兼容性验证：确保相互引用的类之间协调一致。例如在Worker类的gotoWork()方法中会调用Car类的run()方法。Java虚拟机在验证Worker类时，会检查在方法区内是否存在Car类的run()方法，加入不存在（当Worker类和Car类的版本不兼容，就会出现这种问题），就会抛出NoSuchMethodError错误。
5.2、类的准备：
在准备阶段，Java虚拟机为类的静态变量分配内存，并设置默认的初始值。
5.3、类的解析：
在解析阶段，Java虚拟机会把类的二进制数据中的符号引用替换为直接引用。例如在execute()方法中会引用a类的doSomething()方法。
public void execute(){
    a.doSomething(); //在execute()方法所在类的二进制数据中表示为符号引用
}
在execute()方法所在类的二进制数据中表示为符号引用，它由execute()方法的全名和相关描述符组成。在解析阶段，Java虚拟机会报这个符号引用替换为一个指针，该指针指向a类的doSomething()方法在方法区的内存位置，这个指着就是直接引用。


6、类的初始化：
在初始化阶段，Java虚拟机指向类的初始化语句，为类的静态变量赋予初始值，在程序中，静态变量的初始化有两种途径：
① 在静态变量的声明处进行初始化；
② 在静态代码块中进行初始化。
public class A{
    private static int a = 1;  //在静态变量的声明处进行初始化
    private static int b;
    private static int c;




    static{
        b = 2;   //在静态代码块中进行
    }
}
静态变量的声明语句，以及静态代码块都被看做类的初始化语句，Java虚拟机会按照初始化语句在 类文件中的先后顺序来依次执行它们。例如下面B类被初始化后，a = 3;
public class B{
    private static int a = 1;
    static{
        a = 2;
    }
    static{
        a = 3;
    }
}
① 类的准备阶段：赋予默认值a = 0
② 类的初始化：a = 1 a = 2 a = 3
6.1、类的初始化步骤：
① 如果这个类还没有被加载和连接，那就先进行加载和连接。
② 如果存在直接的父类，并且这个父类还没有呗初始化，那就先初始化直接父类。
③ 如果类中存在初始化语句，那就依次执行这些初始化语句。
Example:
public class FinalTest {




    public static void main(String[] args) {
        System.out.println(FinalTest1.a);
    }
}




class FinalTest1{
    public static final int a = 2/1;




    static{
        System.out.println("static code block");
    }
}
输出结果：2
static没有被执行，类没有被初始化，因为a是编译时的常量(final 修饰并且可以编辑器可以计算出结果)。
Example:
public class FinalTest {




    public static void main(String[] args) {
        System.out.println(FinalTest1.a);
    }
}




class FinalTest1{
    public static final int a = new Integer(1);




    static{
        System.out.println("static code block");
    }
}
输出结果：
static code block
1




先执行了static，类被初始化，因为a是非编译时的常量（虽然是final 修饰 ，但是编译器无法计算结果）。




6.2、类的初始化时机：
当Java虚拟机初始化一个类时，要求它的所有父类都已经被初始化，但是，这条规则并不适用于接口。
① 在初始化一个类时，并不会优先初始化它所实现的接口。
② 在初始化一个接口时，并不会优先初始化它的父接口。
因此，一个父接口并不会因为它的子接口或者实现类的初始化而初始化。只有当程序首次使用特定接口的静态变量时，才会导致该接口的初始化。
Example:
启动类，先加载Test1：
public class Test1 {




    static{
        System.out.println("Test1 static block");
    }
    public static void main(String[] args) {
        System.out.println(Child.b);
    }
}
然后初始化父类和子类：
class Parent {
    static int a = 1;




    static{
        System.out.println("Parent static block");
    }
}
class Child extends Parent{
    static int b = 2;
    static {
        System.out.println("Child static block");
    }
}




输出结果：
Test1 static block
Parent static block
Child static block
2




Example:
public class Test1 {




    static{
        System.out.println("Test1 static block");
    }
    public static void main(String[] args) {
        Parent parent;
        System.out.println("初始化Test1后执行该句");
        parent = new Parent();
        System.out.println(Parent.a);
        System.out.println(Child.b);
    }
}
class Parent {
    static int a = 1;




    static{
        System.out.println("Parent static block");
    }
}
class Child extends Parent{
    static int b = 2;
    static {
        System.out.println("Child static block");
    }
}
输出：
Test1 static block
初始化Test1后执行该句
Parent static block
1
Child static block
2




先初始化Test1，输出"初始化Test1后执行该句"，再初始化父类，输出a，初始化子类，输出b。
对子类的使用会导致父类被初始化，但是对父类的使用不会导致子类的初始化。
只有当程序访问的静态变量或静态方法确实在当前类或当前接口中定义时，才可以认为是对类或接口的主动使用。
调用ClassLoader类的loadClass方法加载一个类，并不是对类的主动使用，不会导致类的初始化。




7、手动加载类：
public abstract class ClassLoader
extends Object
类加载器是负责加载类的对象。ClassLoader 类是一个抽象类。如果给定类的二进制名称，那么类加载器会试图查找或生成构成类定义的数据。一般策略是将名称转换为某个文件名，然后从文件系统读取该名称的“类文件”。
每个 Class 对象都包含一个对定义它的 ClassLoader 的引用。




相关方法：
getSystemClassLoader
public static ClassLoader getSystemClassLoader()
返回委托的系统类加载器。该加载器是新的 ClassLoader 实例的默认委托父类加载器，通常是用来启动应用程序的类加载器。
在运行时启动序列的早期首先调用此方法，这时会创建系统类加载器并将其设置为调用 Thread 的上下文类加载器。
默认的系统类加载器是此类的一个与实现有关的实例。
如果在第一次调用此方法时定义系统属性 "java.system.class.loader"，那么该属性的值就是将作为系统类加载器返回的那个类的名称。该类是使用默认系统类加载器进行加载的，它必须定义一个公共的构造方法，此构造方法带有用作委托父类加载器的 ClassLoader 类型的单个参数。然后可以使用将默认系统类加载器用作参数的此构造方法创建一个实例。得到的类加载器被定义为系统类加载器。
如果存在安全管理器，且调用者的类加载器既不是 null，也不同于或不是系统类加载器的祖先，那么该方法将使用 RuntimePermission("getClassLoader") 权限调用安全管理器的 checkPermission 方法，以检验系统类加载器的访问权。如果无此权限，则抛出 SecurityException 异常。
返回：
委托的系统 ClassLoader，如果没有这样的类加载器，则返回 null
抛出：
SecurityException - 如果存在安全管理器，且其 checkPermission 方法不允许访问系统类加载器。
IllegalStateException - 如果在构造由 "java.system.class.loader" 属性指定的类加载器期间进行递归调用。
Error - 如果定义了系统属性 "java.system.class.loader"，但是无法加载指定的类，提供者类没有定义所需的构造方法，或者在调用该构造方法时抛出异常。可以通过 Throwable.getCause() 方法找出导致该错误的基本原因。
loadClass
public Class<?> loadClass(String name)
                   throws ClassNotFoundException
使用指定的二进制名称来加载类。此方法使用与 loadClass(String, boolean) 方法相同的方式搜索类。Java 虚拟机调用它来分析类引用。调用此方法等效于调用 loadClass(name, false)。
参数：
name - 类的二进制名称
返回：
得到的 Class 对象
抛出：
ClassNotFoundException - 如果没有找到类
二进制名称
按照《Java Language Specification》的定义，任何作为 String 类型参数传递给 ClassLoader 中方法的类名称都必须是一个二进制名称。
有效类名称的示例包括：
   "java.lang.String"
   "javax.swing.JSpinner$DefaultEditor"
   "java.security.KeyStore$Builder$FileBuilder$1"
   "java.net.URLClassLoader$3$1"
public class ClassLoaderTest {




    public static void main(String[] args) throws ClassNotFoundException {
        ClassLoader loader = ClassLoader.getSystemClassLoader();
        Class<?> clazz = loader.loadClass("com.itzhai.jvm.C");
        System.out.println("上面的代码不会初始化C类");
        clazz = Class.forName("com.itzhai.jvm.C");
    }
}




class C{
    static {
        System.out.println("ClassLoaderTest static block");
    }
}
loadClass并不会执行静态代码块，没有初始化。调用ClassLoader类的loadClass方法并不会初始化一个类，并不是对类的主动使用，不会导致类的初始化。