23种设计模式之创建型模式：单例模式

问题一：单例模式是什么？

问题二：为什么要单例模式，单例模式解决了什么问题？

问题三：什么情况下需要使用单例模式？

对于开头三联问，你是否能答得出来？

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。

这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。
这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象

注意：

1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。

单例模式意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

主要解决：一个全局使用的类频繁地创建与销毁。

什么时候使用：当您想控制实例数目，节省系统资源的时候。

如何实现：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。

关键代码：构造函数是私有的。

优点：
1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例
2、避免对资源的多重占用（比如写文件操作）。

缺点：
没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化

实现方式：五种

1、饿汉式

是否多线程安全：是
是否懒加载：否
描述：这种方式比较常用，但容易产生垃圾对象。
优点：没有加锁，执行效率会提高。
缺点：类加载时就初始化，浪费内存。

//饿汉式 单例 浪费内存
public class Hungry {
    private Hungry(){

    }
    private final static Hungry instance = new Hungry();

    public static Hungry getInstance(){
        return instance;
    }
}

2、懒汉式

是否多线程安全：是
是否懒加载：是

描述：这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。

优点：第一次调用才初始化，避免内存浪费。
缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。

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

3、双检锁/双重校验锁（DCL，即 double-checked locking）

JDK 版本：JDK1.5 起
是否懒加载：是
是否多线程安全：是

描述：这种方式采用双锁机制，安全且在多线程情况下能保持高性能。

//完整的DCL懒汉式单例 : 用时才创建
public class Lazy {
    private Lazy(){}
    
    private volatile static Lazy instance;

    //双重检测锁模式的懒汉式 简称 DCL懒汉式
    public static Lazy getInstance(){
       if(instance==null){  //第一次判断
           synchronized (Lazy.class){ // 加锁
               if(instance==null) // 第二次判断
                   //new 不是一个原子性操作，可能发生指令重排 所以需要 给实例加上volatile
                   instance = new Lazy();//如果没有实例 再创建实例
           }
       }
        return instance;
    }
 }

4、静态内部类

是否懒加载：是

是否多线程安全：是

描述：这种方式能达到双检锁方式一样的功效，但实现更简单。
对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。
这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。
这种方式只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance。
JVM保证了线程安全，JVM加载Class时 只加载了一次 加载 外部类时 并不会一并加载内部类 而只有当调用了 getInstance方法时才会加载内部类(实现懒加载)

public class Singleton {  
    private Singleton (){}  
    
    public static final Singleton getInstance() {  
   		 return SingletonHolder.INSTANCE;  
    }  

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

5、枚举类

JDK 版本：JDK1.5 起

是否懒加载：否
是否多线程安全：是

描述：这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。
它是唯一能 不被反射创建对象的方式。

//枚举类
public enum MyEnum {
    instance;

    public static  MyEnum getInstance(){
        return instance;
    }
}

tips

一般情况下，建议使用第 1 种饿汉方式。只有在要明确实现 lazy loading 效果时，才会使用第 4 种静态内部类方式。如果涉及到反序列化创建对象时，可以尝试使用第 5 种枚举方式。如果有其他特殊的需求，可以考虑使用第 2 种双检锁（DCL）方式。
（除了枚举类，其他方式都会被反射创建对象，也就是说反射能破坏实例对象的唯一性）

源码所在处：

资料来源：菜鸟教程