笔记：在Java中如何正确写一个单例模式？

单例模式定义：

一个类只有一个实例，提供全局的唯一入口。比如分身术，但是每一个分身都对应同一个真身。

单例模式优点：

• 写法简单
• 线程安全
• 防止破坏单例

为什么需要单例模式

• 理由一：节省内存、节省计算
  • 例如：下面类初始化是需要查询数据库，并对查到的数据做大量的计算，所以在第一次构造的时候，花了很多时间来初始化这个对象；
    但是假设我们数据库里的数据是不变的，并且把这个对象保存在了内存中，那么以后就可以用同一个实例了。
    如果每次都重新生成新的实例，实在是没有必要。

  public class ExpensiveResource {
      public ExpensiveResource(){
          field1 = // 查询数据库
          field2 = // 然后对查询的数据库做大量计算
          field3 = // 加密、压缩等耗时操作
      }
  }
  

• 理由二：保证结果的正确
  • 例如：一个全局计数器，用来统计人数，那么有多个实例的话反而会造成混乱。
• 理由三：方便管理
  • 例如：很多工具类，我们只需要一个实例，那么我们通过一个统一的入口，比如通过getInstance 方法，获取到单例，很方便。

单例模式适用场景

• 无状态工具类
  • 日志工具类
    只是用于记录日志信息，不需要在操作类实例对象上存储任何状态
  • 字符串工具
• 全局信息类
  • 全局计数
  • 环境变量

单例模式写法

• 饿汉式

public class Singleton {
    private static Singleton singleton = new Singleton();
    
    private Singleton(){}
    
    public static Singleton getInstance(){
        return singleton;
    }
}

类装载的时候就完成了实例化，避免了线程同步的问题；==缺点在于类装载的时候就完成了实例化，没有达到懒加载的效果==；如果一直未使用该实例，就造成了内存浪费。

静态代码块式写法：

public class Singleton {
    private static Singleton singleton;
    
    static {
        singleton = new Singleton();
    }
    
    private Singleton(){}
    
    public static Singleton getInstance(){
        return singleton;
    }
}

• 懒汉式

线程不安全式写法：

public class Singleton {
    private static Singleton singleton;
    
    private Singleton(){}
    
    public static Singleton getInstance(){
        if(singleton == null){  //多线程进入会产生多实例
            singleton = new Singleton();
        }
        return singleton;
    }
}

public class Singleton {
    private static Singleton singleton;
    
    private Singleton(){}
    
    public static  Singleton getInstance(){
        if(singleton == null){  //多线程进入会产生多实例
            synchronized (Singleton.class){
                singleton = new Singleton();
            }
        }
        return singleton;
    }
}

调用时进行实例化，起到懒加载效果，只能在单线程下使用，避免多线程环境下使用该写法 

线程安全式写法：

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

效率太低

• 双重检查式

public class Singleton {
    private static volatile Singleton singleton;
    
    private Singleton(){}
    
    public static  Singleton getInstance(){
        if(singleton == null){
            synchronized (Singleton.class){
                if(singleton == null){  //多线程进入会产生多实例
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

两个if判断，第二次if判断会跳过if代码块，直接return 实例化对象；优点不仅线程安全，而且延迟加载，效率更高。缺点不能防止被反序列化，生成多个实例。

扩展思考1：为什么要double-check? 去掉第二次的check行不行呢？

思考：两个线程同时调用getInstance方法，并且由于singleton是空的，所以两个线程都可以通过第一重的if判断，然后由于锁机制的存在，会有一个线程先进入同步语句，并进入第二重的if判断，而另一个线程就会在外面等待，不过当第一个线程执行完 new Singleton() 语句后，就会退出 synchronized 保护的区域，如果没有第二重singleton == null的话，那么第二个线程也会创建一个实例，这就破坏了单例；如果第一check去掉，那么所有线程都会串行执行，效率低下，所以两个check都需要保留的。

扩展思考2：为什么要加volatile关键字？

思考：主要在于singleton = new Singleton() 不是原子操作。防止了JVM中重排序的发生，避免了1->3->2顺序执行过程中拿到未完成初始化的对象。

在JVM中代码执行步骤：
1）给singleton分配初始空间；
2）调用Singleton的构造函数等来初始化singleton；
3）将singleton对象指向分配的内存空间（执行完这步singleton就不是 null 了）。

由于JVM中存在==重排序现象==，执行熟悉存在 1->3->2 或者 1->2->3

• 静态内部类式

public class Singleton {
    
    private Singleton(){}
    
    private static class SingletonInstance{
        private static final Singleton singleton = new Singleton();
    }
    
    public static  Singleton getInstance(){
        return SingletonInstance.singleton;
    }
}

饿汉式机制类似，采用类装载机制，来保证我们初始化实例时只有一个线程，所以JVM保证了线程的安全性；
不会在类装载时实例化，而是在需要调用时实例化。优点不仅线程安全，而且延迟加载，效率更高。
缺点不能防止被反序列化，生成多个实例。

• 枚举式（最佳方式）

public class EnumSingleton {
    
    INSTANCE;
    
    public EnumSingleton getInstance(){
       return INSTANCE;  
    }
}

1.写法简单，代码短小精悍，代码更简洁更优雅；
2.线程安全有保证，枚举中的各个枚举项都是通过static代码来定义和初始化的，他们会在类被加载时完成初始化，而Java类的加载由JVM保证线程安全，所以创建一个Enum 类型的枚举是线程安全的。
3.防止单例破坏，java专门对枚举序列化做了规定，在序列化是仅仅是将枚举对象的name属性输出到结果中，在反序列化时，就是通过java.lang.Enum的valueOf来根据名字查找对象，而不是新建一个新的对象，所以防止了反序列化。

如何选择：

Joshua Bloch 在《Effective Java》书中明确表达过一个观点：使用枚举实现单例的方法，虽然还没有被广泛采用，但是单元素的枚举类型已经成为了实现 Singleton 的最佳方法。

Ref：卫星君