写了这么多次单例模式，你真的学会单例设计模式了吗？

单例模式看似简单，但如果往深了挖掘，又能考察出对并发，类加载，序列化等掌握程度。

Restricts the instantiation of class to one “single” instance.

限制一个类(Class) 只有一个实例，并且提供一个全局可以访问的入口。

为什么使用单例

1. 节省内存，节省计算。

   如数据库的连接，只需要一次，如果每次创建新的实例则会浪费大量内存空间

2. 保证结果的正确性

   一个全局的计数器，用来统计人数，多个实例，反而会造成混乱。

常见的单例模式写法：

饿汉式

懒汉式

双检锁式

静态内部类式

枚举式

饿汉式

package A01;

public class Singleton {
	
    // 类加载的时候就完成了实例化
    // 缺点： 同样，没有达到(lazy-loading)的效果，如果一直未用，可能会造成内存的浪费
    private static Singleton singleton = new Singleton();
    
    // 构造器
    private Singleton(){}
    
    public static Singleton getInstance(){
        return singleton;
    }

    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        
        //true
        System.out.println(s1  == s2 );
    }
}

饿汉式的变种-- 静态代码块方式

package A02;

public class Singleton {
    private static Singleton singleton;
	
    // 将类加载的过程放在了静态代码块之中
    static {
        singleton = new Singleton();
    }

    private Singleton(){}

    public static Singleton getInstance(){
        return singleton;
    }

    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();

        System.out.println(s1 == s2);
    }

}

懒汉式

package A03;

// 懒加载方式的写法
public class Singleton {
    private static Singleton singleton;

    private Singleton(){}
	
    // 在getInstance() 方法被调用时， 才会实例化对象
    //只可以在多线程下使用，如果两个线程同时进入"if (singleton == null)语句",遍会多次初始化这个实例对象
    
    public static Singleton getInstance(){
        
        if (singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }


    public static void main(String[] args) {
     Singleton s1 = Singleton.getInstance();
     Singleton s2 = Singleton.getInstance();
     System.out.println(s1 == s2);

    }

}

线程安全的懒汉式写法

package A04;

public class Singleton {
    private static Singleton singleton;

    private Singleton(){}
	
    // 加上synchronized 来修饰，不过，缺点是：效率太低了
    public static synchronized Singleton getInstance(){
        if (singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }

    public static void main(String[] args) {

    }
}

双层检查锁的方式

package A05;
// 线程安全  + 延迟加载
public class Singleton {
    // 防止重拍序，volatile 保证内存的可见性
    private static volatile Singleton singleton;

    private  Singleton(){}

	//两次  if (singleton == null) 保证线程的安全
    public static Singleton getInstance(){
        if (singleton == null){
            synchronized (Singleton.class){
                if (singleton == null){
                    // 加volatile的原因， 这并非是原子操作 
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }

    // 双层检测锁

    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();

        System.out.println(s1 == s2);
    }

}

// double-check 原理： 
// 两个线程同时调用getInstance() 方法，Singleton 是空的，两个线程都可以通过第一重if 判断，锁的存在，只能有一个线程可以获得锁，进入同步语句，并进入第二次if 判断

// 另外一个线程在外面等待，当第一个线程执行完 初始化new 对象的时候，如果没有第二层检测锁"if (singleton == null)" 第二个线程也会创建实例

// 如果去掉第一个check 所有线程都只会串行执行，效率低下。

 singleton = new Singleton();

这句话，做了三件事

1. 给singleton 分配内存空间

2. 调用Singleton 的构造函数，初始化singleton

3. singleton 对象指向分配的内存空间(执行完 之后 singleton != null )

同样，注意第二句和第三句，这两句之间存在这指令重新排序的优化 —> 第二步和第三部的执行顺序是不能保证的。

执行顺序可能是1->2->3 或者 1->3->2

volatile 防止内存指令的重排序，避免拿到了未完成初始化的对象。

静态内部类的方式

package A06;

public class Singleton {
    private Singleton(){}
	
    // 与饿汉式的方式类似
    private static class SingletonInstance{
        private static final Singleton singleton = new Singleton();
    }
	
    // 需要实例时，才会初始化对象
    public static Singleton getInstance(){
        return SingletonInstance.singleton;
    }


    public static void main(String[] args) {
        Singleton s1 = new Singleton();
        Singleton s2 = new Singleton();

        System.out.println(s1 == s2);
    }
}

最好的一种方式

枚举方式的写法

package A07;

// 使用枚举 生成 Singleton
public enum  Singleton {
    INSTANCE;
    public void whateverMethod(){

    }

    public static void main(String[] args) {
        // 简单安全
        Singleton s1 = Singleton.INSTANCE;
        Singleton s2 = Singleton.INSTANCE;
        System.out.println(s1 == s2);

    }
}

//避免多线程同步问题，防止反序列化`反射创建新的对象

简洁

线程安全

防止破坏单例

防止反序列化

Effective Java中对Singleton 的描述

Item 3: Enforce the singleton property with a private
constructor or an enum type