Java单例模式的多种写法

1、饿汉式

class SingletonHunger{
    /**
     * 在类加载的时候就创建实例，即便INSTANCE还没被使用，也创建实例，这种方式叫做饿汉式。
     * jvm加载类的时候能保证线程安全，直接避免了多线程步问题
     */
    private final static SingletonHunger INSTANCE = new SingletonHunger();

    private SingletonHunger() {
    }

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

2、懒汉式

class SingleLazy{
    /**
     * 类加载的时候不创建对象，instance为null。等到首次被调用的时候才会创建实例，这种方式叫懒汉式
     */
    // 错误定义instance的方式
    private static SingleLazy instance;
    
    // 正确定义instance的方式 
    //private static volatile SingleLazy instance;
    
    private SingleLazy() {
    }

    public static SingleLazy getInstance(){
        if (instance == null){
            synchronized (SingleLazy.class){
                if (instance == null){
                    instance = new SingleLazy();
                }
            }
        }
        return instance;
    }
}

懒汉式用到了双重检查（Double Check），但是对于java来说双重检查并不能保证单例的安全性。因为计算机处理器为了提高性能，会对指令进行重排序，看以下代码：

对指令重排序后，这3行代码执行后的结果是一样的，但是重排序后的机器指令减少了，提高了性能。

JVM创建对象 instance = new SingleLazy() 大致可以分为3个步骤：

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

这3个步骤可能进行指令重排序，后面两个步骤调换，变为

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

当创建对象的代码变成这样时，双重检查有可能出现bug。看下面的双重检查代码

1、线程1执行完 instance = memory （B处的代码），instance已经指向内存地址了，不为null。但是还没执行初始化对象的方法ctorInstance()，比如SingleLazy构造函数中有this.a=XX; this.b=YY之类的代码没执行。

2、此时线程2获得CPU资源，线程2进入getInstance()方法，运行 if(instance == null) 得到结果为false，不进入if代码里面，直接返回instance，此时的instance是一个没初始化完成的SingleLazy实例。

这种情况很难使用java代码模拟出来，下面用一种比较诡异的方式，给大家展示得到一个未初始化完实例的代码。

/**
 * 模拟得到一个未初始化完成对象的例子，
 * 在对象的构造函数内将this赋值给外部对象，并在赋值后等待一段时间
 * 在睡眠期间其他线程获取此对象，得到的就一个未初始化完成的对象
 */
public class UnfinishedObj {
    private final int x, y;

    public UnfinishedObj(int x, int y){
        this.x = x;
        TestUnfinishedObj.instance = this;
        try {
            TimeUnit.SECONDS.sleep(2);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        this.y = y;
    }

    @Override
    public String toString() {
        return "UnfinishedObj{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }
}

public class TestUnfinishedObj {
    static UnfinishedObj instance;
    public static void main(String[] args) throws Exception{
        new Thread(() -> {
            instance = new UnfinishedObj(1,2);
        }).start();

        TimeUnit.SECONDS.sleep(1);
        System.out.println("未初始化完成的实例"+ instance);
        TimeUnit.SECONDS.sleep(2);
        System.out.println("已经初始化完成的实例"+ instance);
    }
}

了解指令重排序是导致双重检查（Double Check）失效的原因，我们只需要在创建对象的时候禁止计算机进行指令重排序即可，幸运的是java提供了此功能，只需要在定义instance变量时加上volatile关键字即可。

    // 正确定义单例变量的方式 ，禁止指令重排序，并保证变量在线程之间的可见性
    private static volatile SingleLazy instance;

3、静态内部类方式

class SingletonObj {
    private SingletonObj() {
    }

    public static SingletonObj getInstance() {
        return SingletonHolder.INSTANCE;
    }

    /**
     * 静态内部类
     * 外部类加载的时候，内部类和静态内部类不会被加载，也就不会创建SingletonObj实例，实现了懒加载
     * 静态内部类只会被加载一次，能保证静态内部类成员变量初始化的线程安全
     */
    private static class SingletonHolder {
        private static final SingletonObj INSTANCE = new SingletonObj();
    }
}

4、枚举方式

/**
 * 枚举实现单例
 * 枚举类型是线程安全的，并且只会装载一次。并且能防止反序列化破坏单例
 */
enum SingleEnum{

    INSTANCE;

    public void method1(){
        System.out.println("业务代码");
    }
}

class UseSingleEnum {
    public static void main(String[] args) {
        SingleEnum.INSTANCE.method1();
    }
}