概述：
5分钟理解设计模式系列，将通过解决实际问题，来带您理解设计模式，本文希望带您搞懂的3个问题是：
- 为什么使用单例模式？
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对象，不符合单例模式。
最后，期待您的订阅和点赞，专栏每周都会更新，希望可以和您一起进步，同时也期待您的批评与指正！
