JVM系列(7)，三分钟带你入门redis高可用架构之哨兵模式

代码模拟类加载过程：

public class HelloLoader {

    public static void main(String[] args) {

        System.out.println("谢谢ClassLoader加载我....");

        System.out.println("你的大恩大德，我下辈子再报！");

    }

} 

它的加载过程是怎么样的呢?

• 执行 main() 方法（静态方法）就需要先加载承载类 HelloLoader

• 如果加载成功，则进行链接、初始化等操作，完成后调用 HelloLoader 类中的静态方法 main

• 如果加载失败则抛出异常

完整的流程图如下所示：加载阶段 --> 链接阶段（验证 --> 准备 --> 解析） --> 初始化阶段

加载阶段：

• 通过一个类的全限定名获取定义此类的二进制字节流

• 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构

• 在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口

加载class文件的方式：

①从本地系统中直接加载

②通过网络获取，典型场景：Web Applet

③从zip压缩包中读取，成为日后jar、war格式的基础

④运行时计算生成，使用最多的是：动态代理技术

⑤由其他文件生成，典型场景：JSP应用从专有数据库中提取.class文件，比较少见

⑥从加密文件中获取，典型的防Class文件被反编译的保护措施

链接阶段： 验证 --> 准备 --> 解析

• 验证(Verify)

  • 目的在于确保Class文件的字节流中包含信息符合当前虚拟机要求，保证被加载类的正确性，不会危害虚拟机自身安全

  • 主要包括四种验证，文件格式验证，元数据验证，字节码验证，符号引用验证。

举例：使用 BinaryViewer 工具（一个二进制字节码转换器）查看字节码文件，其开头均为 CAFE BABE ，如果出现不合法的字节码文件，那么将会验证不通过

• 准备(Prepare)

  • 为类变量分配内存并且设置该类变量的默认初始值，即零值

  • 这里不包含用final修饰的static，因为final在编译的时候就会分配好了默认值，准备阶段会显式初始化

  • 这里不会为实例变量分配初始化，类变量会分配在方法区中，而实例变量是会随着对象一起分配到Java堆中

举例：private static int a = 1; 声明一个变量a，变量a在准备阶段会赋初始值，但不是1，而是0（默认初始值），在初始化阶段会被赋值为 1

• 解析(Resolve)

  • 将常量池内的符号引用转换为直接引用的过程

  • 事实上，解析操作往往会伴随着JVM在执行完初始化之后再执行

  • 符号引用就是一组符号来描述所引用的目标。符号引用的字面量形式明确定义在《java虚拟机规范》的class文件格式中。直接引用就是直接指向目标的指针、相对偏移量或一个间接定位到目标的句柄

  • 解析动作主要针对类或接口、字段、类方法、接口方法、方法类型等。对应常量池中的CONSTANT Class info、CONSTANT Fieldref info、CONSTANT Methodref info等

符号引用：反编译 class 文件后可以查看符号引用

初始化阶段：

• 初始化阶段就是执行类构造器方法<clinit>() 的过程

• 此方法不需定义，是javac编译器自动收集类中的所有类变量的赋值动作和静态代码块中的语句合并而来（当代码中包含static变量时，<clinit>() 自动生成，如果没有静态代码快则不会生成）。

• <clinit>()方法中的指令按语句在源文件中出现的顺序执行

• <clinit>()不同于类的构造器。（关联：构造器是虚拟机视角下的<init>()）

• 若该类具有父类，JVM会保证子类的<clinit>()执行前，父类的<clinit>()已经执行完毕

• 虚拟机必须保证一个类的<clinit>()方法在多线程下被同步加锁

IDEA 中安装 JClassLib 插件（重启 IDEA 后生效）：

（1）File -> Settings

（2）安装插件：Plugins -> Install jclasslib

（3）选中对应的 .class文件：

（4）点击View -> Show Bytecode With jclasslib，查看反编译后的代码

（5）查看反编译后的代码：

构造器方法中指令按语句在源文件中出现的顺序执行：

public class ClassInitTest {

    private static int num = 1;

   

    private static int number = 10;      //linking之prepare: number = 0 --> initial: 10 --> 20

    static {

        num = 2;

        number = 20;

        System.out.println(num);

        //System.out.println(number);    //报错：非法的前向引用（可以赋值，但不能调用）

    }

	//private static int number = 10;      //linking之prepare: number = 0 --> initial: 10 --> 20

   

    public static void main(String[] args) {

        System.out.println(ClassInitTest.num);//2

        System.out.println(ClassInitTest.number);//10

    }

} 

运行结果：分别测试静态变量在静态代码块之前、之后执行

如果静态变量在静态代码块之后执行，在静态代码块中引用该变量时会报非法向前引用错误：

构造器是虚拟机视角下的<init>()

public class ClinitTest {

    //任何一个类声明以后，内部至少存在一个类的构造器

    private int a = 1;

    private static int c = 3;



    public static void main(String[] args) {

        int b = 2;

    }



    public ClinitTest(){

        a = 10;

        int d = 20;

    }



} 

运行结果：

若该类具有父类，JVM会保证子类的()执行前，父类的()已经执行完毕：

public class ClinitTest1 {

    static class Father{

        public static int A = 1;

        static{

            A = 2;

        }

    }



    static class Son extends Father{

        public static int B = A;

    }



    public static void main(String[] args) {

        //加载Father类，其次加载Son类。

        System.out.println(Son.B);//2

    }

} 

运行结果是2，因为Son类是Father类的子类，在执行Son类的加载前会先执行Father类的加载。

虚拟机必须保证一个类的<clinit>()方法在多线程下被同步加锁：

public class DeadThreadTest {

    public static void main(String[] args) {

        Runnable r = () -> {

            System.out.println(Thread.currentThread().getName() + "开始");

            DeadThread dead = new DeadThread();

            System.out.println(Thread.currentThread().getName() + "结束");

        };



        Thread t1 = new Thread(r, "线程1");

        Thread t2 = new Thread(r, "线程2");



        t1.start();

        t2.start();

    }

}



class DeadThread {

    static {

        if (true) {

            System.out.println(Thread.currentThread().getName() + "初始化当前类");

            while (true) {



            }

        }

    }

} 

结果分析：

• 两个线程同时去初始化 DeadThread 类，而 DeadThread 类中静态代码块中有一处死循环，切该类只能被初始化一次

• 所以先初始化 DeadThread 类的线程抢到了同步锁，然后在类的静态代码块中执行死循环，而另一个线程在等待同步锁的释放

• 所以运行结果是：某一个线程先执行 DeadThread 类的初始化，而另外一个类不会继续执行

  

类加载器的分类

---

JVM支持两种类型的类加载器 ，分别为引导类加载器（Bootstrap ClassLoader）和自定义类加载器（User-Defined ClassLoader）。

• 从概念上来讲，自定义类加载器一般指的是程序中由开发人员自定义的一类类加载器，但是Java虚拟机规范却没有这么定义，而是将所有派生于抽象类ClassLoader的类加载器都划分为自定义类加载器，所以ExtClassLoader 和 AppClassLoader 都属于自定义加载器。

四者之间是包含关系，不是上层和下层，也不是子父类的继承关系：

测试类加载器：

public class ClassLoaderTest {

    public static void main(String[] args) {



        //获取系统类加载器

        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();

        System.out.println(systemClassLoader);

        //sun.misc.Launcher$AppClassLoader@18b4aac2



        //获取其上层：扩展类加载器

        ClassLoader extClassLoader = systemClassLoader.getParent();

        System.out.println(extClassLoader);

        //sun.misc.Launcher$ExtClassLoader@1540e19d



        //获取其上层：获取不到引导类加载器

        ClassLoader bootstrapClassLoader = extClassLoader.getParent();

        System.out.println(bootstrapClassLoader);

        //null



        //对于用户自定义类来说：默认使用系统类加载器进行加载

        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();

        System.out.println(classLoader);

        //sun.misc.Launcher$AppClassLoader@18b4aac2



        //String类使用引导类加载器进行加载的。---> Java的核心类库都是使用引导类加载器进行加载的。

        ClassLoader classLoader1 = String.class.getClassLoader();

        System.out.println(classLoader1);

        //null



    }

} 

• 在获取引导类加载器时，获取到的值为 null ，因为引导类加载器由 C/C++ 语言编写，我们无法获取

• 两次获取系统类加载器的值都相同 ，说明系统类加载器全局唯一

虚拟机自带的加载器：

启动类加载器（引导类加载器，Bootstrap ClassLoader）

• 这个类加载使用C/C++语言实现的，嵌套在JVM内部

• 它用来加载Java的核心库（JAVA_HOME/jre/lib/rt.jar、resources.jar或sun.boot.class.path路径下的内容），用于提供JVM自身需要的类

• 并不继承自java.lang.ClassLoader，没有父加载器

• 加载扩展类和应用程序类加载器，并作为他们的父类加载器（当他俩的爹）

• 出于安全考虑，Bootstrap启动类加载器只加载包名为java、javax、sun等开头的类

扩展类加载器（Extension ClassLoader）

• Java语言编写，由sun.misc.Launcher$ExtClassLoader实现

• 派生于ClassLoader类

• 父类加载器为启动类加载器

• 从java.ext.dirs系统属性所指定的目录中加载类库，或从JDK的安装目录的jre/lib/ext子目录（扩展目录）下加载类库。如果用户创建的JAR放在此目录下，也会自动由扩展类加载器加载

应用程序类加载器（系统类加载器，AppClassLoader）

• Java语言编写，由sun.misc.LaunchersAppClassLoader实现

• 派生于ClassLoader类

• 父类加载器为扩展类加载器

• 它负责加载环境变量classpath或系统属性java.class.path指定路径下的类库

• 该类加载是程序中默认的类加载器，一般来说，Java应用的类都是由它来完成加载

• 通过classLoader.getSystemclassLoader()方法可以获取到该类加载器

代码举例说明：

public class ClassLoaderTest1 {

    public static void main(String[] args) {



        System.out.println("**********启动类加载器**************");

        //获取BootstrapClassLoader能够加载的api的路径

        URL[] urLs = sun.misc.Launcher.getBootstrapClassPath().getURLs();

        for (URL element : urLs) {

            System.out.println(element.toExternalForm());

        }

        //从上面的路径中随意选择一个类,来看看他的类加载器是什么:引导类加载器

        ClassLoader classLoader = Provider.class.getClassLoader();

        System.out.println(classLoader);//null，证明我们无法获取到启动类加载器



        System.out.println("***********扩展类加载器*************");

        String extDirs = System.getProperty("java.ext.dirs");

        for (String path : extDirs.split(";")) {

            System.out.println(path);

        }



        //从上面的路径中随意选择一个类,来看看他的类加载器是什么:扩展类加载器

        ClassLoader classLoader1 = CurveDB.class.getClassLoader();

        System.out.println(classLoader1);//sun.misc.Launcher$ExtClassLoader@1540e19d



    }

} 

运行结果：

用户自定义类加载器：

在Java的日常应用程序开发中，类的加载几乎是由上述3种类加载器相互配合执行的，在必要时，我们还可以自定义类加载器，来定制类的加载方式。那为什么还需要自定义类加载器？

• 隔离加载类

• 修改类加载的方式

• 扩展加载源

• 防止源码泄漏

如何自定义类加载器？

• 开发人员可以通过继承抽象类java.lang.ClassLoader类的方式，实现自己的类加载器，以满足一些特殊的需求

• 在JDK1.2之前，在自定义类加载器时，总会去继承ClassLoader类并重写loadClass()方法，从而实现自定义的类加载类，但是在JDK1.2之后已不再建议用户去覆盖loadClass()方法，而是建议把自定义的类加载逻辑写在findclass()方法中

• 在编写自定义类加载器时，如果没有太过于复杂的需求，可以直接继承URLClassLoader类，这样就可以避免自己去编写findclass()方法及其获取字节码流的方式，使自定义类加载器编写更加简洁。

代码示例：

public class CustomClassLoader extends ClassLoader {

    @Override

    protected Class<?> findClass(String name) throws ClassNotFoundException {



        try {

            byte[] result = getClassFromCustomPath(name);

            if (result == null) {

                throw new FileNotFoundException();

            } else {

                return defineClass(name, result, 0, result.length);

            }

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        }



        throw new ClassNotFoundException(name);

    }