设计模式之单例模式

1、设计模式（23种）

创建型模式：单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式

结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式

行为模式：命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式
状态模式、策略模式、职责链模式、访问者模式

2、单例模式

2.1、作用

保证一个类只有一个实例，并且提供一个访问该实例的全局访问点

2.2、优点

由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他以来对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决

单例模式可以在系统设置全局的访问点，优化共享资源访问，例如可以设置一个单例类，负责所有数据表的映射

2.3、常见的单例模式实现

2.3.1、饿汉式（线程安全，调用效率高，不能延迟加载）

public class EagerSingleton 
{
    private static EagerSingleton instance = new EagerSingleton();
    /**
     * 私有默认构造函数
     */
    private EagerSingleton(){}
    /**
     * 静态工厂方法
     */
    public static EagerSingleton getInstance(){
        return instance;
    }
}

饿汉式是典型的空间换时间，当类装载的时候就会创建类的实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断，节省了运行时间。

2.3.2、懒汉式（线程安全，调用效率不高，可以延迟加载）

public class LazySingleton
{
    private static LazySingleton instance = null;
    /**
     * 私有默认构造函数
     */
    private LazySingleton(){}
    /**
     * 静态工厂方法
     */
    public static synchronized LazySingleton getInstance(){
        if(instance == null){
            instance = new LazySingleton();
        }
        return instance;
    }
}

懒汉式是典型的时间换空间,就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。当然，如果一直没有人使用的话，那就不会创建实例，则节约内存空间，由于懒汉式的实现是线程安全的，这样会降低整个访问的速度，而且每次都要判断。那么有没有更好的方式实现呢？

2.3.3、双重检查锁式（由于jvm底层内部模型原因，偶尔会出问题，不建议使用）

可以使用“双重检查加锁”的方式来实现，就可以既实现线程安全，又能够使性能不受很大的影响。那么什么是“双重检查加锁”机制呢？

所谓“双重检查加锁”机制，指的是：并不是每次进入getInstance方法都需要同步，而是先不同步，进入方法后，先检查实例是否存在，如果不存在才进行下面的同步块，这是第一重检查，进入同步块过后，再次检查实例是否存在，如果不存在，就在同步的情况下创建一个实例，这是第二重检查。这样一来，就只需要同步一次了，从而减少了多次在同步情况下进行判断所浪费的时间。

“双重检查加锁”机制的实现会使用关键字volatile，它的意思是：被volatile修饰的变量的值，将不会被本地线程缓存，所有对该变量的读写都是直接操作共享内存，从而确保多个线程能正确的处理该变量。

注意：在java1.4及以前版本中，很多JVM对于volatile关键字的实现的问题，会导致“双重检查加锁”的失败，因此“双重检查加锁”机制只只能用在java5及以上的版本。

public class DoubleCheckSingleton
{
    private volatile static DoubleCheckSingleton instance = null;
    private DoubleCheckSingleton(){}
    public static DoubleCheckSingleton getInstance(){
        //先检查实例是否存在，如果不存在才进入下面的同步块
        if(instance == null){
            //同步块，线程安全的创建实例
            synchronized (DoubleCheckSingleton.class) {
                //再次检查实例是否存在，如果不存在才真正的创建实例
                if(instance == null){
                    instance = new DoubleCheckSingleton();
                }
            }
        }
        return instance;
    }
}

这种实现方式既可以实现线程安全地创建实例，而又不会对性能造成太大的影响。它只是第一次创建实例的时候同步，以后就不需要同步了，从而加快了运行速度。

提示：由于volatile关键字可能会屏蔽掉虚拟机中一些必要的代码优化，所以运行效率并不是很高。因此一般建议，没有特别的需要，不要使用。也就是说，虽然可以使用“双重检查加锁”机制来实现线程安全的单例，但并不建议大量采用，可以根据情况来选用。

根据上面的分析，常见的两种单例实现方式都存在小小的缺陷，那么有没有一种方案，既能实现延迟加载，又能实现线程安全呢？

2.3.4、静态内部类式（线程安全，调用效率高，可以延迟加载）

这个模式综合使用了Java的类级内部类和多线程缺省同步锁的知识，很巧妙地同时实现了延迟加载和线程安全。

public class StaticClassSingleton 
{
    private StaticClassSingleton() {
    }

    /**
     * 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例
     * 没有绑定关系，而且只有被调用到时才会装载，从而实现了延迟加载。
     */
    private static class SingletonHolder {
        /**
         * 静态初始化器，由JVM来保证线程安全
         */
        private static StaticClassSingleton instance = new StaticClassSingleton();
    }

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

2.3.5、枚举单例（线程安全，调用效率高，不能延迟加载）

单元素的枚举类型已经成为实现Singleton的最佳方法。用枚举来实现单例非常简单，只需要编写一个包含单个元素的枚举类型即可。

public enum EnumSingleton 
{
    /**
     * 定义一个枚举的元素，它就代表了Singleton的一个实例。
     */
    uniqueInstance;

    /**
     * 单例可以有自己的操作
     */
    public void singletonOperation() {
        //功能处理
    }
}

使用枚举来实现单实例控制会更加简洁，而且无偿地提供了序列化机制，并由JVM从根本上提供保障，绝对防止多次实例化，是更简洁、高效、安全的实现单例的方式。

3、反射和反序列化漏洞及解决方案

看 Test 包里面的代码就行了 https://gitee.com/leungzengjian/GOF23/tree/master/src/Singleton/Test

4、git

https://gitee.com/leungzengjian/GOF23/tree/master/src/Singleton