5分钟理解设计模式系列，将通过解决实际问题，来带您理解设计模式

内容目录（由[TOC]自动生成）

概述：1 为什么使用单例模式？处理资源访问表示全局唯一2 你有哪些实现单例模式的方法？1 饿汉式：2 双重检测懒汉式3 静态内部类4 枚举3 单例模式是[金手指]吗？选读：低版本的jdk为什么需要使用到volatile关键字修饰？

概述：

  本文希望带您搞懂的3个问题是：

1. 为什么使用单例模式？
   2.你有哪些实现单例模式的方法？
   3.单例模式是[金手指]吗？

1 为什么使用单例模式？

  单例模式（Singleton Design Pattern），一个类只允许创建一个对象（或者实例），这个类就是一个单例类，这种设计模式，就叫做单例模式。
  单例模式主要用于：处理资源访问冲突与表示全局唯一。

处理资源访问

  例如：我们有一个Logger类，通过FileWriter类来记录日志，记录日志的文件位置是：info.log，我们在程序中可能会有很多地方需要记录日志，那么如果我们每一次记录日志，都创建一个Logger类的话，那么每一个Logger类都会去写info.log文件（每个Logger对应一个FileWriter，多个FileWriter同时写入），此时info.log就是一个竞争资源，两个线程同时写入数据，就可能出现数据覆盖的情况。但是如果Logger类是一个单例类，那么由于FileWriter是一个线程安全的对象，那么就不会出现数据覆盖的问题。

表示全局唯一

  在我们的程序开发过程中，有一些类需要被表示成全局唯一，比如我们的配置文件在系统中只有一份，那么当配置文件被加载到内存后，以对象的形式存在，也应该存一份，再比如全局的id自增生成器、线程池、对象池等对象，也可以设计成单例。

2 你有哪些实现单例模式的方法？

1 饿汉式：

1public class Singleton {
   private Singleton() {
   }
   private static Singleton singleton = new Singleton();
   public Singleton getInstance(){
       return singleton;
   }
8}
复制代码

  在类加载的时候，创建对象，有人觉得这种实现方式不好，因为不支持延迟加载。
  但是我并不认同这种说法，因为如果该对象加载耗时非常长，那么最好不要等到真正去使用它的时候，再去初始化，因为这样会影响性能，甚至会由于接口响应时间过长导致超时失败。如果该实力占用资源较多，可能会引起程序报错（比如 Java 中的 PermGen Space OOM），那么在程序初始化时抛出异常，我们还可以进行调整，但是如果这个异常是在程序运行时抛出的，那么会导致整个程序崩溃，所以有问题应该提早暴露，遵循fail-fast的设计原则

2 双重检测懒汉式

 1public class Singleton {
   private Singleton() {
   }
   private static Singleton singleton = null;
   public Singleton getInstance(){
       // 提高性能，降低线程进入临界区的可能
       if(singleton == null){
           synchronized (Singleton.class){
               if(singleton == null){
                   singleton = new Singleton();
               }
           }
       }
       return singleton;
   }
16}
复制代码

  这也是单例模式比较经典的写法，网上有人说由于指令重排，需要在加volatile关键字，禁止指令重排。实际上这个问题在高版本的jdk中已经修复了，修复方法是将对象的new操作改成原子操作。低版本的指令重排问题产生的原因我也写在了文章的最后，感兴趣的同学也可以了解一下。

3 静态内部类

这是一种比双重检测的单例模式更简单的写法，也可以做到延迟加载：

 1public class Singleton {
   private Singleton() {
   }
   public static Singleton getInstance() {
       return Inner.singleton;
   }
   private static class Inner {
       private static Singleton singleton = new Singleton();
   }
10}
复制代码

  该方法使用的是静态内部类的特性，外部类被加载的时候，不会创建Inner实例对象，只有调用 getInstance方法的时候，才会创建Sigleton对象，创过程中的线程安全，Singleton的唯一性均由JVM保证

4 枚举

枚举是一种最简单的实现方式，通过java枚举类的特性，保证唯一性。

1public enum Singleton  {
   INSTANCE 
   //doSomething 该实例支持的行为
   //可以省略此方法，通过Singleton.INSTANCE进行操作
   public static Singleton get Instance() {
       return Singleton.INSTANCE;
   }
8}
复制代码

3 单例模式是[金手指]吗？

并不是，单例模式也存在着一些问题
对OOP的特性不友好（不基于接口、对继承、多态并不友好）
不支持有参数的构造函数
对程序的可测试性不友好
对程序的扩展性不友好
如果单例模式的成员变量是全局变量，一但被修改将影响其他调用类
所以我们可以用过工厂模式、或者是ioc容器来代替单例模式，当然使用那种对象创建方法，还应该根据具体的业务而定。

选读：低版本的jdk为什么需要使用到volatile关键字修饰？

 1public class Singleton {
   private Singleton() {
   }
   private volatile Singleton singleton = null;
   public Singleton getInstance(){
       // 提高性能，降低线程进入临界区的可能
       if(singleton == null){
           synchronized (Singleton.class){
               if(singleton == null){
                   singleton = new Singleton();
               }
           }
       }
       return singleton;
   }
16}
复制代码

代码中有两处判空：

第一处判空，是为了提高性能，降低线程进入临界区的可能性。

第二处判空是为了线程同步，假如没有第二处判空，则可能两个线程都通过了if(singleton==null)条件，这样即使是临界区内只有一个线程在执行，临界区内的代码也会被执行两遍，这样就会产生两个对象，不符合单例模式。

成员变量使用了volatile进行修饰，一方面是保证了对象在多线程环境下的可见性，另一方面是为了防止new Singleton()进行指令重排序而导致的并发问题。
volatile关键字的作用两个：
1 保证变量在线程之间的可见性（直接从主存中读写数据，不经过工作内存）
2 阻止编译时和运行时的指令重排，编译时JVM编译器遵循内存屏障约束，运行时依赖CPU屏障来阻止指令重排。

指令重排是指JVM在编译Java代码的时候，或者CPU在执行JVM字节码的时候，对现有的指令顺序进行重新排序。

指令重排的目的是为了在不改变程序执行结果的前提下，优化程序的运行效率。需要注意的是，这里所说的不改变执行结果，指的是不改变单线程下的程序执行结果。

这里不太好懂，举一个例子，正常的new Singleton()创建步骤是：

1 开辟一块内存空间

2 创建对象

3 将对象的地址存入引用变量

经过指令重排后，可能变成了：

1 开辟一块内存空间

2 将对象的地址存入引用变量

3 创建对象

假设发生了指令重排，线程A、B都执行这段代码，线程A执行到了new Singleton()的步骤2，此时还没有创建对象，这个时候发生了线程的切换。线程B开始执行，这个时候线程B还可以通过if(singleton == null)的判断，因为线程A中的singleton只是指向了一个空的内存地址，这个时候线程B创建出了一个Singleton对象，当线程切换成A时，线程A仍执行了new Singleton()的步骤3，此时创建了2个Singleton对象，不符合单例模式。

最后，期待您的订阅和点赞，专栏每周都会更新，希望可以和您一起进步，同时也期待您的批评与指正！