单例模式(Singleton Pattern)

1. 引言

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一，属于设计模式中的创建型模式，这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。单例模式应用于要求只存在一个单例类对象的场景，如线程池，注册表，如果创建出不只一个该类的实例那就会出现问题。

2. 注意

单例模式的实现有多种不同的实现，每种实现都有其优缺点，有些缺点明显，选择合适的实现非常重要。

3. 实现

饿汉式

优点	缺点
线程安全	非懒加载
效率高	不能阻止反射攻击
实现简单

class Singleton{
    private static final Singleton INSTANCE = new Singleton();

    private Singleton(){};

    public static Singleton getInstance(){
        return INSTANCE;
    }
}
复制代码

优点：

• 同样饿汉式里的线程安全性是由类加载机制保证。
• 因为调用方法获取实例时不需要进行同步，相比需要线程同步的实现方式效率更高。
• 代码量少，实现简单

缺点：

• 非懒加载是指类初始化时就创建实例对象，而不等到需要该对象时调用getInstance()方法才创建对象，导致提早创建对象，如果对象很大时而之后不需要用，那就太占有内存了。
• 即使构造函数是私有的，但是却可以利用反射机制去访问构造函数从而创建出不只一个对象，这就违背了单例模式的原则。

懒汉式（非线程安全）

优点	缺点
懒加载	非线程安全
效率高	不能阻止反射攻击
实现简单

public class Singleton {
    private static Singleton instance;
    
    private Singleton(){};

    public static Singleton getInstance(){
        if (instance == null)
            instance = new Singleton();
        return instance;
    }
}
复制代码

缺点： 不具备线程安全性，严格意义来说不能算单例模式。

懒汉式（线程安全）

优点	缺点
线程安全	效率低
懒加载	不能阻止反射攻击
实现简单

public class Singleton {
    private static Singleton instance;
    
    private Singleton(){};

    public static synchronized Singleton getInstance(){
        if (instance == null)
            instance = new Singleton();
        return instance;
    }
}
复制代码

缺点： 虽然实现了线程安全性，但是这种实现方法导致每次访问getInstance()方法时都要加锁，效率大大下降。

双重检验锁(Double Checked Locking)

优点	缺点
线程安全	不能阻止反射攻击
效率高	较复杂
懒加载

class Singleton{
    private volatile static Singleton instance;

    private Singleton(){};

    public static Singleton getInstance(){
        if (instance == null){
            synchronized (Singleton.class){
                if (instance == null)
                    instance = new Singleton();
            }
        }
        return instance;
    }
}
复制代码

优点： DCL的线程安全性是通过加锁来保证的，而且加锁的过程只是发生在第一次获取对象的时候，所以效率还是很高。还有一个重要的点就是instance字段要用volatile修饰来禁止指令重排。

静态内部类(Static Inner Class)

优点	缺点
线程安全	不能阻止反射攻击
效率高
懒加载

class Singleton{

    private Singleton(){};

    private static class SingletonHolder{
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance(){
        return SingletonHolder.INSTANCE;
    }
}
复制代码

枚举(Enum)

优点	缺点
线程安全	非懒加载
效率高
实现简单
可阻止反射攻击
提供序列化机制，并且反序列化时可避免出现多个实例

enum Singleton {  
    INSTANCE; 
}  
复制代码

优点：

• 枚举里面的INSTANCE字段是public static final Singleton类型的，线程安全性有类加载阶段保证，因此不需要进行额外的同步操作，效率高，实现简单。
• 反射机制已经针对了枚举类型的对象做了处理，可以保证不能通过反射机制创建多个对象，所以可以阻止反射攻击。
• 同样的，序列化机制也对枚举类型的对象做了处理，在序列化的时候仅仅是将枚举对象的name属性序列化，反序列化的时候则是通过Enum 的 valueOf() 方法来根据名字查找枚举对象。因此反序列化后的实例也会和之前被序列化的对象实例相同。

---

现在发现只有枚举提供了阻止反射攻击和避免反序列化多个不同实例的序列化机制，那其他实现方法可不可以提供这两种功能呢，答案是可以的。

1. 对于反射来说，虽然构造函数是私有的，但反射可以通过访问私有的构造函数来创建多个对象。既然是单例模式，那么我们可以在创建第二个抛出异常。只需修改构造函数，如下：

private static boolean TAG;
private Singleton(){
        if (TAG){
            throw new IllegalArgumentException("Cannot create object");
        }else {
            TAG = true;
        }
    }
复制代码

2. 要让对象支持序列化操作，该对象的类需要implements Serializable，并且在类中增加一个方法private Object readResolve()，这个方法会在反序列化完后调用，其中返回的对象替代了原来反序列化生成的对象。如下：

private Object readResolve(){
        return INSTANCE;
    }
复制代码

4. 最后

就以上来看，我觉得实现单例的最佳方式应该是静态内部类和枚举，其中静态内部类真是优点满满啊。对于枚举来说，别看简简单单只写出两三行代码，其实它是java的一颗语法糖，反编译过后你就知道它干货满满。而且要知道它背后反射和序列化对它做的优化，知识点真心不少。