单例模式

简介

• 这一模式的目的是使得类的一个对象成为系统中的唯一实例。
  -要实现这一点，可以从客户端对其进行实例化开始。因此需要用一种只允许生成对象类的唯一实例的机制，“阻止”所有想要生成对象的访问。使用工厂方法来限制实例化过程。
• 这个方法应该是静态方法（类方法），因为让类的实例去生成另一个唯一实例毫无意义。

1. 一是某个类只能有一个实例；
2. 二是它必须自行创建这个实例；
3. 三是它必须自行向整个系统提供这个实例。

饱汉型：

pubic class Singleton {
    private static Singleton instance = new Singleton();
    private Singleton() {}
    public static Singleton getInstance() {
        return instance;
    }
}

对象在类中被定义为private static，通过getInstance(),通过java的classLoader机制保证了单例对象唯一。
Singleton类在类加载时就被初始化，对instance进行实例化。
天生线程安全，类加载机制保证

饿汉型：

public class Singleton {
    private static Singleton instance = null;
    private Singleton() {}
    public static synchronized Singleton getInstance() {
        if (instance == null)
            instance = new Singleton();
        return instance;
    }
}

实现了延迟初始化
但需要synchronized来保证线程安全。

dcl双重检查：

public class Singleton {
    private static volatile Singleton instance = null;
    private Singleton() {}
    public static Singleton getInstance() {
            // here1
        if (instance == null) {
                // here
            synchronized(Singleton.class) {
                if (instance == null)
                    instance = new Singleton();  // 
            }
        }
        return instance;
    }

}

第一个if (instance == null) 是因为大多数情况下 instance != null
第二个if (instance == null) 是因为可能会存在多个线程执行到here,
例如A，B线程都到了here，然后A先向下执行，new一个Singleton对象，
A执行完后，B向下执行，如果没有if (instance == null)判断B线程也会直接new一个Singleton对象。
就不是单例了。


instance使用volatile修饰的原因：

instance = new Singleton(); 这一行代码存在3个步骤

memory = allocate();    //1，分配对象的内存空间
ctorInstance(memory);   //2，初始化对象
instance = memory;      //3，设置instance指向刚分配的内存地址

2和3之间可能会被重排序。


memory = allocate();    //1，分配对象的内存空间
instance = memory;      //3，设置instance指向刚分配的内存地址
                        // 注意，此时对象还没有被初始化！
ctorInstance(memory);   //2，初始化对象

重排序在单线程情况下不会出现问题，但是在多线程情况下，会出现问题

比如A线程执行到here1,B线程执行到instance = new Singleton();
因为指令重排序，执行到了3，还没执行2，这时instance != null A线程往下走，
会直接return instance,但此时的instance还没初始化。


将instance用volatile修饰后，通过内存屏障，2、3的指令重排序会被禁止。

内部类实现线程安全的懒加载

public class Singleton {

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

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

利用类加载实现 懒加载

只要应用中不使用内部类，JVM就不会去加载这个单例类，也就不会创建单例对象，
从而实现懒汉式的延迟加载。也就是说这种方式可以同时保证延迟加载和线程安全

枚举类实现单列模式

好处： 能够 防止 反射，序列化，克隆 对单列模式的破环

public enum SingletonClass {
    INSTANCE;

    public void doSomeThing() {

    }
}