代码仓库：https://gitee.com/yangsiyuan/Design-Pattern

创建型设计模式：聚焦于实例化对象，通常提供一种隐藏创建逻辑的形式，取代直接使用new运算符实例化对象

写在前面的话：

• 一般而言，建议使用2.3 饿汉模式；
• 若明确需要懒汉模式，建议使用2.5 静态内部类模式；
• 有装逼需求，建议使用2.4 双重检验锁模式；
• 如果涉及到反序列化创建对象时，可以尝试使用2.6 枚举模式

1. 定义

单例模式是最简单的设计模式，提供一个类用于创建自己的对象，并且只允许有一个对象被创建

• 核心定义：保证一个类仅有一个实例，并对外提供访问入口

• 优点：避免了频繁地创建与销毁对象

• 应用场景：Spring容器中管理的bean默认即为单例模式(scope=singleton)，且默认为饿汉模式，即容器启动时为所有的bean均构造一个实例。

2. 代码实现

实现注意点：

1. 类的构造方法必须是private，不允许直接new对象

2. 对外提供一个static方法，供外部获取实例

2.1 懒汉模式(线程不安全)

懒汉模式：即在使用对象的时候，才去创建对象

public class Singleton {  
    // 定义一个static的本对象
    private static Singleton instance;  
    
    // 构造方法私有
    private Singleton (){}  
  
    // 静态方法，供外部调用【此处线程不安全，可能同时被调用，构造多个对象】
    public static Singleton getInstance() { 
        // 判断是否已存在对象
        if (instance == null) {  
            // 不存在则new一个
            instance = new Singleton();  
        }  
        return instance;  
    }  
    
    // 属性及其getter、setter省略
    ......
}


public class SingletonPatternTest {
   public static void main(String[] args) {
      //获取唯一可用的对象
      Singleton object = Singleton.getInstance();
      ......
   }
}

2.2 懒汉模式(线程安全)

相较于"2.1 懒汉模式(线程不安全)"，对getInstance进行加锁，保证线程安全

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
    // 通过synchronized进行加锁
    public static synchronized Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}

2.3 饿汉模式

饿汉模式：即类加载时就创建对象，基于 classloader 机制避免了多线程的同步问题

• 优点：无需加锁，即可保证线程安全，效率高

• 缺点：类加载时就初始化，浪费内存

public class Singleton {  
 // 类加载时，即构建对象
 private static Singleton instance = new Singleton();
 private Singleton (){}
 public static Singleton getInstance() {
 return instance;
 }
}

2.4 双重检验锁模式(懒汉优化)

双重锁模式：通过对象锁，在多线程情况下保持高性能

• 优化原理：2.2中每次仅允许一个线程调用getSingleton()；但是当前方法，允许同时调用getSingleton，若singleton ！= null则直接返回实例，只有singleton为空时，才会触发锁机制

public class Singleton {  
 private volatile static Singleton singleton;
 private Singleton (){}
 public static Singleton getSingleton() {
 if (singleton == null) {
 // 对Singleton.class加锁
 synchronized (Singleton.class) {
 if (singleton == null) {
 singleton = new Singleton();
 }
 }
 }
 return singleton;
 }
}

2.5 静态内部类模式(懒汉优化)

该方法，与双检锁方式结果一样，但实现更简单

1. 基于classloader机制加载SingletonHolder类，保证了只有一个实例

2. 只有在调用getInstance()方法的时候，才会触发INSTANCE实例的初始化，实现了懒汉

public class Singleton {  
 private Singleton (){} 

 // 静态内部类，SingletonHolder被调用时触发，实际为懒加载效果；
 // 同时利用classloader 机制来保证初始化 instance 时只有一个线程
 private static class SingletonHolder {
 private static final Singleton INSTANCE = new Singleton();
 }

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

2.6 枚举模式

Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化

public enum EnumSingleton {
    // 枚举，只会有一个实例
    INSTANCE;

    public void whoAreU(String name, Integer age){
        System.out.println("my name is" + name + ", i am " + age + "years old!!");
    }
}