创建型模式 - 单例模式

“Yeah It’s on. ”

创建型模式 - 单例模式

一、介绍

• 定义

单例模式（Singleton Pattern）是一个比较简单得模式，定义如下：
确保某一个类只有一个实例，且自行实例化并向整个系统提供这个实例。

• 使用场景

  • 要求生成唯一序列号得环境；
  • 在整个项目中需要一个共享访问点或共享数据，例如一个Web页面上的计数器，可以不用把每次刷新记录到数据库中，使用单例模式 保持计数器的值，并确保是线程安全的；
  • 创建一个对象需要消耗资源过多，如访问IO和数据库等资源；
  • 需要定义大量的静态常量和静态方法（如：工具类）的环境，可以采用单例模式（当然也可以直接声明为static的方式）；

二、特点

• 单例模式的优点

  • 单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁地创建、销毁时，而且创建或销毁时性能又无法优化， 单例模式的优势就非常明显；
  • 单例模式只生成一个实例，所以减少了系统的性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象， 然后用永久驻留内存的方式来解决（在Java EE中采用单例模式时需要注意JVM垃圾回收机制）；
  • 单例模式可以避免对资源的多重占用，例如一个写文件动作，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作；
  • 单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理；

• 单例模式的缺点

  • 单例模式一般没有接口，扩展很困难，若要扩展，除了修改代码基本上没有第二种途径可以实现。单例模式为什么不能增加接口呢？因为接口对单例模式是没有任何意义的，它要求“自行实例化”，并且提供单一实例、接口或抽象类是不可能被实例化的。当然，在特殊情况下，单例模式可以实现接口、被继承等，需要在系统开发中根据环境判断。

  • 单例模式对测试是不利的。在并行开发环境中，如果单例模式没有完成，是不能进行测试的，没有接口也不能使用mock的方式虚拟一个对象。

  • 单例模式与单一职责原则有冲突。一个类应该只实现一个逻辑，而不关心它是否是单例的，是不是要单例取决于环境，单例模式把“要单例”和业务逻辑融合在一个类中。

三、单例模式的实现方式

1.饿汉模式（线程安全）

饿汉式单例模式在类加载时完成了初始化，所以类加载较慢，如果不使用的浪费内存空间，但获取对象的速度快(空间换时间)。

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

2.懒汉模式（线程不安全）

没有考虑到线程安全，可能存在多个访问者同时访问，并同时构造了多个对象的问题。
针对懒汉模式线程不安全的问题，我们自然想到了，在getInstance()方法前加锁，于是就有了下面第3种实现。

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

3.懒汉模式（线程安全）

并发其实是一种特殊情况，大多时候这个锁占用的额外资源都浪费了，这种打补丁方式写出来的结构效率很低。

public class SingletonDemo {
    private static SingletonDemo instance;
    private SingletonDemo(){}
    public static synchronized SingletonDemo getInstance(){   //加锁 synchronized修饰方法
        if(instance == null){
            instance = new SingletonDemo();
        }
        return instance;
    }
}

4.双重校验锁法

接下来我解释一下在并发时，双重校验锁法会有怎样的情景：

1. 线程A访问getInstance()方法，因为单例还没有实例化，所以进入了锁定块。
2. 线程B访问getInstance()方法，因为单例还没有实例化，得以访问接下来代码块，而接下来代码块已经被线程1锁定。
3. 线程A进入下一判断，因为单例还没有实例化，所以进行单例实例化，成功实例化后退出代码块，解除锁定。
4. 线程B进入接下来代码块，锁定线程，进入下一判断，因为已经实例化，退出代码块，解除锁定。

理论上双重校验锁法是线程安全的，并且，这种方法实现了lazyloading（时间换空间）。

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

5.双重校验锁法（volatile）

对于4中双重校验这种可能出现的问题：

• 实例化对象的那行代码instance = new SingletonDemo()，实际上可以分解成以下三个步骤：

1. 分配内存空间
2. 初始化对象
3. 将对象指向刚分配的内存空间

• 但是有些编译器为了性能的原因，可能会将第二步和第三步进行重排序，顺序就成了：

1. 分配内存空间
2. 将对象指向刚分配的内存空间
3. 初始化对象 (在这种情况下，线程B对instance的访问，访问的有可能是一个初始化未完成的对象)

• 解决方案是：只需要给instance的声明加上volatile关键字即可，volatile版本如下：

public class SingletonDemo {
    private volatile static SingletonDemo instance; //volatile关键字的一个作用是禁止指令重排
    private SingletonDemo(){}
    public static SingletonDemo getInstance(){
        if(instance == null){
            synchronized (SingletonDemo.class){
                if(instance == null){
                    instance = new SingletonDemo();
                }
            }
        }
        return instance;
    }
}

6.静态类内部加载（线程安全）

静态内部类不会在单例加载时就加载，而是在调用getInstance()方法时才进行加载，达到了类似懒汉模式的效果，这种方法又是线程安全的

public class SingletonDemo {
    private SingletonDemo(){}
    public static SingletonDemo getInstance(){
        return SingletonHolder.instance;
    }
    private static class SingletonHolder{  //静态类内部
        private static SingletonDemo instance = new SingletonDemo();
    }
}

7.枚举方法（线程安全）

Josh Bloch 对这个方法的评价：
这种写法在功能上与共有域方法相近，但是它更简洁，无偿地提供了串行化机制，绝对防止对此实例化，即使是在面对复杂的串行化或者反射攻击的时候。虽然这中方法还没有广泛采用，但是单元素的枚举类型已经成为实现Singleton的最佳方法。

枚举单例这种方法问世以来，许多分析文章都称它是实现单例的最完美方法——写法超级简单，而且又能解决大部分的问题。
这种方法虽然很优秀，但是它仍然不是完美的,比如，在需要继承的场景，它就不适用了.

public class SingletonDemo {
    private SingletonDemo(){}
    public static SingletonDemo getInstance() {
        return Singleton.INSTANCE.getSingle();
    }
    private static enum Singleton {
        INSTANCE;
        private SingletonDemo instance;
        private Singleton () {
            instance = new SingletonDemo();
        }
        public SingletonDemo getSingle() {
            return instance;
        }
    }
}

四、最佳实践

单例模式是23个模式中比较简单的模式，应用也非常广泛，如在Spring中，每个Bean默认就是单例的，这样坐的优点是Spring容器可以管理这些Bean的生命周期，决定什么时候创建出来，什么时候销毁，销毁的时候如何处理等等。如果采用非单例模式（Prototype类型），则Bean初始化的管理交友J2EE容器，Spring容器不再跟踪管理Bean的生命周期。摘自《设计模式之禅》