单例模式

今天来介绍下设计模式中的单例模式，那么何为单例模式了：

简介

单例模式(Singleton Pattern)：确保一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。单例模式是一种对象创建型模式。

从上面的定义中，可以概括出几个重点：

某个类只能有一个实例
必须自行创建这个实例
必须像整个系统提供这个实例

饿汉式单例

所谓饿汉式单例，是指在定义静态变量的时候实例化单例类，见代码：

public class SingletonDemo{
    private static final SingletonDemo INSTANCE = new SingletonDemo();//在类的内部创建一个类的实例
    private SingletonDemo(){//构造方法私有化
    }
    public static SingletonDemo getInstance(){
        return INSTANCE;
    }
}

懒汉式单例

所谓懒汉式单例，是指在第一次调用时初始化，在类加载的时候并不进行初始化，这种技术又称为延迟加载（Lazy Load），为了避免多线程中同时调用getInstance()方法，是需要用synchronized同步的，代码如下：

class SingletonDemoL{
    private static SingletonDemoL instance = null;
    // 构造方法私有
    private SingletonDemoL(){}
    
    public static SingletonDemoL getInstance(){
        //提高了代码的效率，无须对整个静态方法同步
        if(instance==null) {
            //静态方法中用的同步锁
            synchronized (SingletonDemoL.class) {
               instance = new SingletonDemoL();
            }
        }
        return instance;
    }
}

以上懒汉式在多线程中还是会存在单例对象不唯一的情况，原因如下：
假如有两个线程A和B，同时调用了getInstance()方法，由于此时instance对象为null值，均能通过instance == null的判断。因为加锁的关系，线程A进入同步块中的代码创建实例，此时的线程B处于排队等待状态，当A执行完成后，此时的线程B并不知道已经创建过实例了，将继续进入同步块来创建实例，导致产生了多个单例对象。违背了单例设计模式的思想，因此需要再次校验。这种再次校验（instance==null）被称为双重检查锁定（Double Check Locking）。

双重检查锁定单例

代码如下：

class SingletonDemoL{
    private volatile static SingletonDemoL instance = null;
    // 构造方法私有
    private SingletonDemoL(){}
    
    public static SingletonDemoL getInstance(){
        //提高了代码的效率，无须对整个静态方法同步
        //第一重判断
        if(instance==null) {
            //静态方法中用的同步锁
            synchronized (SingletonDemoL.class) {
                // 第二重判断
                if (instance == null) {
                    instance = new SingletonDemoL();
                }
            }
        }
        return instance;
    }
}

注意：如果使用双重检查锁定，是需要在静态成员变量instance前面加修饰符volatile，被它修饰后的变量在多线程中可见。
如果不用volatile修饰，new SingletonDemoL()并不是一个原子操作，最终会被编译成多条汇编指令，它大致的执行流程为以下三个步骤：

给对象实例分配内存空间；
调用对象的构造方法、初始化成员字段；
将 instance 对象指向分配的内存空间。

所以使用关键字 volatile 来修饰 instance 对象，这样就可以防止 CPU 指令重排。

枚举单例(推荐)

现在有一种比较流行的写法，就是枚举单例，代码如下：

public class EnumSingleton { 
    private EnumSingleton() { 
    } 
    public static EnumSingleton getInstance() { 
        return Holder.HOLDER.instance; 
    } 
    private enum Holder { 
        HOLDER; 
        private final EnumSingleton instance; 
        Holder() { 
            instance = new EnumSingleton(); 
        } 
    } 
}

上面的EnumSingleton类是我们要用的单例模式的资源，比如网络连接，数据库连接，线程池等，获取资源的方式也方便，只要如下调用即可

EnumSingletonDemo.INSTANCE.getInstance()

那为什么枚举能实现单例了？大概有如下几点

首先枚举的构造方法是私有的
每个枚举实例都是static，final类型的，也就是只能实例化一次，即枚举中的INSTANCE 可以类比其他单例模式中的写法public static final INSTANCE

另外在Effective Java一书中也提到

单元素的枚举类型已经成为实现Singleton的最佳方法

静态内部类实现单例

静态内部类的实现代码如下：

public class Singleton {
    // 静态内部类
    private static class SingletonInstance {
        private static final Singleton instance = new Singleton();
    }
    // 获取实例（单例对象）
    public static Singleton getInstance() {
        return SingletonInstance.instance;
    }
    private Singleton() {
    }
    // 类方法
    public void sayHi() {
        System.out.println("Hi,Java.");
    }
}

总结

下面来说下单例模式的优缺点

优点

主要优点如下：

单例模式提供了对唯一实例的受控访问。因为单例类封装了它的唯一实例，所以它可以严格控制客户怎样以及何时访问它
由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。
允许可变数目的实例。基于单例模式我们可以进行扩展，使用与单例控制相似的方法来获得指定个数的对象实例，既节省系统资源，又解决了单例单例对象共享过多有损性能的问题

缺点

主要缺点如下：

由于单例模式中没有抽象层，因此单例类的扩展有很大的困难。
单例类的职责过重，在一定程度上违背了“单一职责原则”。因为单例类既充当了工厂角色，提供了工厂方法，同时又充当了产品角色，包含一些业务方法，将产品的创建和产品的本身的功能融合到一起。
现在很多面向对象语言(如Java、C#)的运行环境都提供了自动垃圾回收的技术，因此，如果实例化的共享对象长时间不被利用，系统会认为它是垃圾，会自动销毁并回收资源，下次利用时又将重新实例化，这将导致共享的单例对象状态的丢失。

使用场景

在一下情况下，可以使用单例模式：

系统只需要一个实例对象，如系统要求提供一个唯一的序列号生成器或资源管理器，或者需要考虑资源消耗太大而只允许创建一个对象。
客户调用类的单个实例只允许使用一个公共访问点，除了该公共访问点，不能通过其他途径访问该实例

end，感谢阅读！

# 设计模式

简介