单例模式

最早接触单例模式在学习jdbc的时候，写了个DBUtil，是一个数据库的Connection懒汉式单例。
后来发现懒汉式单例居然还有许多故事。以下是个简单的懒汉式单例

//懒汉式
public class Config {
    private static Config config = null;
    
    private Config() {
    }

    public static Config getConfig() {
        if (config == null) {
            config = new Config();
        }
        return config;
    }
}

emm后来随着"姿势"的增长，听说了这个有猫病。多线程下会创建多个实例，一听好像是那么回事，就简单研究了下。
为解决以上问题，加synchronized锁来限制，如下

public class Config {
    private static Config config = null;

    private Config() {
    }

    public static Config getConfig() {
        synchronized (Config.class) {
            if (config == null) {
                config = new Config();//带出新的问题，可能会指令重排
            }
        }
        return config;
    }
}

这样，解决了创建多个实例的问题，但又带来新的问题，每一次获取connection 都会需要获取锁，效率低下。然后就有大聪明想了一个办法再加一个判断，如下

public class Config {
    private static Config config = null;

    private Config() {
    }

    public static Config getConfig() {
        if (config == null) {
            synchronized (Config.class) {
                if (config == null) {
                    config = new Config();//带出新的问题，可能会指令重排
                }
            }
        }
        return config;
    }
}

这样如果已经实例化，就不需要再获取锁，直接返回connection ，但是 又双叒叕带来新问题了，
jvm执行代码，会根据情况优化程序执行顺序。

 config = new Config();

这一句话，在jvm是这样解释的（没经过指令重排）:

        memory = allocate(); //1：分配对象的内存空间

        ctorInstance(memory); //2：初始化对象

        instance = memory; //3：设置instance指向刚分配的内存地址

经过指令重排之后，可能顺序如下：

        memory = allocate(); //1：分配对象的内存空间

        instance = memory; //2：设置instance指向刚分配的内存地址

        ctorInstance(memory); //3：初始化对象

可以看到指令重排之后，instance指向分配好的内存放在了前面，而对象初始化被排在了后面，在线程A初始化完成初始化对象之前，线程B虽然进不去同步代码块，但是在同步代码块之前的判断就会发现instance不为空，此时线程B获得instance对象进行使用就可能发生空指针错误。

解决方案 加volatile关键字禁止指令重排
private static volatile Config config = null;

以上带来三个新知识点：1synchronized 关键字；2volatile 关键字；3类加载机制
有兴趣的可以继续深入学习

当然常用的是静态内部类的懒加载方式，也能解决以上问题（懒加载，线程安全）。
如下

public class Singleton {
    
    private static class SingletonHolder {
        public static Singleton instance = new Singleton();
    }

    private Singleton() {
    }

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

Java 类的加载过程包括：加载、验证、准备、解析、初始化。初始化阶段即执行类的 clinit 方法（clinit = class + initialize），包括为类的静态变量赋初始值和执行静态代码块中的内容。但不会立即加载内部类，内部类会在使用时才加载。所以当此 Singleton 类加载时，SingletonHolder 并不会被立即加载，所以不会像饿汉式那样占用内存。

另外，Java 虚拟机规定，当访问一个类的静态字段时，如果该类尚未初始化，则立即初始化此类。当调用Singleton 的 getInstance 方法时，由于其使用了 SingletonHolder 的静态变量 instance，所以这时才会去初始化 SingletonHolder，在 SingletonHolder 中 new 出 Singleton 对象。这就实现了懒加载。

第二个问题的答案是 Java 虚拟机的设计是非常稳定的，早已经考虑到了多线程并发执行的情况。虚拟机在加载类的 clinit 方法时，会保证 clinit 在多线程中被正确的加锁、同步。即使有多个线程同时去初始化一个类，一次也只有一个线程可以执行 clinit 方法，其他线程都需要阻塞等待，从而保证了线程安全。