设计模式3：单例模式：静态内部类模式是怎么保证单例且线程安全的？-Toy模板网

这篇具有很好参考价值的文章主要介绍了设计模式3：单例模式：静态内部类模式是怎么保证单例且线程安全的？。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

上篇文章：设计模式3：单例模式：静态内部类单例模式简单测试了静态内部类单例模式，确实只生成了一个实例。我们继续深入理解。

静态变量什么时候被初始化？

public class Manager {

    private static class ManagerHolder {
        private static Manager instance = new Manager();
    }

    private Manager() {
    
    }

    public static Manager getInstance() {
        return ManagerHolder.instance;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println(Manager.getInstance() == Manager.getInstance());
        }
    }
}

这行代码private static Manager instance = new Manager();什么时候执行？

编译期间将.java文件转为.class文件，运行期间根据.class文件，通过类加载生成类的.class对象。并找到main()方法，开始执行。类加载过程的初始化阶段，会给static变量赋值。

类加载过程详解

静态内部类模式是怎么保证单例的？

外部类的加载，并不会引起静态内部类加载，静态内部类只会在被访问的时候才第一次加载。这就实现了懒汉模式。

一个类只会被一个类加载器加载一次。我们验证下：

import java.util.Scanner;

public class Manager {
    static {
        System.out.println("Manager类被加载");
    }

    private static class ManagerHolder {
        static {
            System.out.println("静态内部类ManagerHolder被加载");
        }

        private static Manager instance = new Manager();
    }

    private Manager() {
        System.out.println("构造器：Manager()被调用");
    }

    public static Manager getInstance() {
        System.out.println("进入getInstance()方法");
        return ManagerHolder.instance;
    }

    public static void main(String[] args) {
        System.out.println("\n类加载完成，程序开始执行：");
        Scanner scanner = new Scanner(System.in);
        System.out.print("是否开始访问单例？要开始请输入1\n");
        int start = scanner.nextInt();
        if (start == 1) {
            scanner.close();
            for (int i = 0; i < 5; i++) {
                Manager.getInstance(); //获取5次单例
            }
        }
    }
}

输出结果：
设计模式3：单例模式：静态内部类模式是怎么保证单例且线程安全的？,设计模式,设计模式,单例模式

可以看出，main方法还没有执行的时候，Manager类就已经被加载了。但是ManagerHolder类并没有被加载。输入1之后，第一次调用getInstance()方法，ManagerHolder类才被加载。Manager的构造器也只执行了一次。

一个类只会被类加载器加载一次吗？

是的。
双亲委派模型先检查是否已经被加载过，若没有加载则调用父类加载器的loadClass()方法，依次向上递归。若父类加载器为空则说明递归到启动类加载器了。如果从父类加载器到启动类加载器的上层次的所有加载器都加载失败，则调用自己的findClass()方法进行加载。

使用双亲委派模型能使Java类随着加载器一起具备一种优先级的层次关系，保证同一个类只加载一次，避免了重复加载，同时也能阻止有人恶意替换加载系统类。

双亲委派模型并不是一个强制性的约束模型，而是Java设计者推荐给开发者的类加载器实现方式。

一旦类被加载并初始化，它的字节码和静态数据将留存在内存中，以供后续使用。当需要使用该类时，JVM不会重新加载类的字节码，而是直接使用已加载的类。每次都加载，消耗cpu和内存。

深入理解Java类加载器(ClassLoader)
JVM 基础 - Java 类加载机制

类加载过程是线程安全的吗？

是的。
loadClass()方法的注释有说明：除非被重写，否则在整个类加载过程中，此方法会对getClassLoadingLock()方法的结果进行同步。，说的就是下面那行代码：

java.lang.ClassLoader文章来源地址https://www.toymoban.com/news/detail-523910.html

    /**
     *  ...
     *  
     * <p> Unless overridden, this method synchronizes on the result of
     * {@link #getClassLoadingLock <tt>getClassLoadingLock</tt>} method
     * during the entire class loading process.
     * ...
     * 
     */
    protected Class<?> loadClass(String name, boolean resolve)
            throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {  //用synchronized修饰了getClassLoadingLock()的返回值
            ...
        }
    }