设计模式——单例模式

定义

单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的一个类只有一个实例。即一个类只有一个对象实例。

特点

1. 单例类只能有一个实例。
2. 单例类必须自己创建自己的唯一实例。
3. 单例类必须给所有其他对象提供这一实例。

单例模式保证了全局对象的唯一性，比如系统启动读取配置文件就需要单例保证配置的一致性。

实现单例模式的方式

饿汉式单例（立即加载方式)

// 饿汉式单例
public class Singleton {
    // 私有构造
    private Singleton() {}

    private static Singleton single = new Singleton();

    // 静态工厂方法
    public static Singleton getInstance() {
        return single;
    }
}

单例对象一开始就被new Singleton()主动创建实例供外部使用，则不再需要判空操作,就好像一个饿汉一样，主动寻找食物，可以认为是线程安全的，除非使用java的反射机制，来打破单例，实例化构造方法为private的类

懒汉式单例（延迟加载方式）

// 懒汉式单例
public class Singleton {

    // 私有构造
    private Singleton() {}

    private static Singleton single = null;

    public static Singleton getInstance() {
        if(single == null){
            single = new Singleton();
        }
        return single;
    }
}

单例对象需要被使用的时候才被创建，就好像一个饿汉躺在地上等着人来喂。但在多线程环境下会产生多个single对象，假设Singleton类刚刚被初始化，instance对象还是空，这时候两个线程同时访问getInstance方法，两个线程都会执行判空操作，这样就会被new出两个对象，因此是线程不安全的

双重检测单例

public class Singleton {
    private Singleton() {}  //私有构造函数
   private static Singleton instance = null;  //单例对象
   //静态工厂方法
   public static Singleton getInstance() {
        if (instance == null) {      //双重检测机制
         synchronized (Singleton.class){  //同步锁
           if (instance == null) {     //双重检测机制
             instance = new Singleton();
               }
            }
         }
        return instance;
    }
}

为了防止new Singleton被执行多次，因此在new操作之前加上Synchronized 同步锁，锁住整个类。为什么需要两次判空呢，因为当两个线程同时访问的时候，线程A构建完对象，线程B也已经通过了最初的判空验证，不做第二次判空的话，线程B还是会再次构建instance对象。

需要说明的是，使用了双重检测机制之后单例模式就是绝对的线程安全的吗？

其实不然
这里涉及到一个JVM的指令重排的问题，什么是指令重排呢？
比如java中简单的一句 instance = new Singleton，会被编译器编译成如下JVM指令：

• memory =allocate(); //1：分配对象的内存空间
• ctorInstance(memory); //2：初始化对象
• instance =memory; //3：设置instance指向刚分配的内存地址

指令重排就是这些指令的顺序并不是一直都这样，有可能经过 JVM或CPU的优化，变成下面的样子：

• memory =allocate(); //1：分配对象的内存空间

• instance =memory; //3：设置instance指向刚分配的内存地址

• ctorInstance(memory); //2：初始化对象

这这这…
这样的结果就是：当线程A执行完1 3时，instance对象还未完成初始化，但已经不再指向null。此时如果线程B抢占到CPU资源，执行 if（instance == null）的结果会是false，从而返回一个没有初始化完成的instance对象
那这样不就凉了吗

我们可以给单例对象加上volatile修饰符

public class Singleton {
    private Singleton() {}  //私有构造函数
    private volatile static Singleton instance = null;  //单例对象
    //静态工厂方法
    public static Singleton getInstance() {
          if (instance == null) {      //双重检测机制
         synchronized (Singleton.class){  //同步锁
           if (instance == null) {     //双重检测机制
             instance = new Singleton();
                }
             }
          }
          return instance;
      }
}

这个volatile修饰符的作用就是阻止变量访问前后的指令重排，保证了指令的顺序执行。这样就可以放心心的使用单例模式了（ps:除非你不去用反射打破单例的话）