Java设计模式之单例模式

单例模式的写法保证了内存中只有该类的一个实例对象，从写法上划分，大致可以分为饿汉式与懒汉式。本文介绍饿汉式的两种写法与懒汉式的两种写法。

懒汉式

内部静态方法创建单例

使用内部静态方法创建单例的写法要考虑到线程安全，因此可以用synchronized关键字为创建单例对象的代码加锁。
在synchronized之前还要判断INSTANCE是否为空，是为了避免每个线程要获取单例时都先去抢占锁，提高了性能。
注意，仅仅使用了synchronized关键字还是不够的，还需要用volatile关键字修饰INSTANCE,这里volatile起到的作用是禁止指令重排序。

public class Lazy1 {
    private static volatile Lazy1 INSTANCE; //volatile禁止指令重排序

    private Lazy1() {}

    public static Lazy1 getInstance() {
        if(INSTANCE == null) {
            synchronized(Lazy1.class) {
                if(INSTANCE == null) {
                    INSTANCE = new Lazy1();
                }
            }
        }

        return INSTANCE;
    }
    
}

思考：如果不加volatile，一旦发生了指令重排序会怎么样？
我们要避免的是这行代码发生指令重排序

 INSTANCE = new Lazy1();

这行创建实例对象的代码从执行顺序上可以再分为三个步骤：

1.申请空间
2.创建对象
3.让引用指向对象

一旦发生指令重排序，步骤2与步骤3 顺序颠倒，步骤3执行了，而步骤2还没执行，也就是说，当对象还未创建时，INSTANCE就不为null了。如果此时其他线程也来调用getInstance()方法，则会直接得到一个INSTANE，然而这个INSTANCE指向的对象还未创建，这就是线程不安全的。

因此，在高并发的场景下，我们要想办法避免任何可能出错的地方，即使是可能性很小的指令重排序，我们也要用volatile去解决。

---

利用内部静态类懒加载

public class Lazy2 {
    private Lazy2(){}

    //只有getInstance()被调用时，内部静态类InternalClass才会被加载
    private static class InternalClass {
        private static final Lazy2 INSTANCE = new Lazy2();
    }

    public static Lazy2 getInstance() {
        return InternalClass.INSTANCE;
    }
}

饿汉式

加载类时直接创建单例对象

public class Hungry1 {
    private static final Hungry1 INSTANCE = new Hungry1();

    private Hungry1(){}

    public static Hungry1 getInstance(){
        return INSTANCE;
    }
}

使用枚举

这是利用了JVM保证每个枚举类型以及其定义的枚举变量在JVM中是唯一的特性。

public enum Hungry2 {
    INSTANCE;

    //可以省略此方法，直接用Hungry2.INSTANCE取得
    public static Hungry2 getInstance() {
        return INSTANCE;
    }
}