单例.png

概述：

5分钟理解设计模式系列，将通过解决实际问题，来带您理解设计模式，本文希望带您搞懂的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 饿汉式：

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

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

2 双重检测懒汉式

public 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;
    }
}

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

3 静态内部类

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

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

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

4 枚举

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

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

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

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

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

public 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;
    }
}

代码中有两处判空：
　　第一处判空，是为了提高性能，降低线程进入临界区的可能性。
　　第二处判空是为了线程同步，假如没有第二处判空，则可能两个线程都通过了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对象，不符合单例模式。

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