java单例模式的各种实现以及DCL的注意事项

饿汉式

class Singleton {
    private static final Singleton1 instance = new Singleton1();

    private Singleton() {

    }

    public static Singleton getInstance() {
        return instance;
    }
}

要点：
1.私有化构造器
2.创建唯一的一个对象，并提供获取方法

缺点：
类加载的时候就会创建实例，但是不一定会用到，有可能会造成内存的浪费

懒汉式：同步方法

class Singleton {
    private static Singleton instance;

    private Singleton() {

    }

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

懒汉式：DCL

class Singleton {
    private static volatile Singleton instance;  // 加volatile是为了禁止指令重排序，防止得到半成品实例
    private static final Object o = new Object();

    private Singleton() {

    }

    //  DCL双重检查
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (o) {
                if (instance == null) {
                    instance = new Singleton();
                    return instance;
                }
            }
        }
        return instance;
    }
}

解释一下加volatile的作用：
首先创建一个对象大致有三步：1.分配一块内存空间；2.调用构造方法初始化；3.建立引用变量和对象之间的引用关系。
如果不加volatile，则可能发生指令重排序，导致第二步和第三步的执行顺序发生交换，导致有可能拿到一个半成品对象，如下图：

两次检查的作用：
如果只有一次检查是否为null，则可能不再是单例，如下图：

静态内部类

class Singleton {
    private Singleton() {

    }

    public static Singleton getInstance() {
        return SingletonInstance.instance;  // 多个线程拿到的都是同一个
    }

    private static class SingletonInstance {
        //  因为是static所以只会被执行一次，从而保证单例
        //  有点类似于饿汉式的思想（不过是懒加载的）
        private static final Singleton instance = new Singleton();
    }
}

静态内部类的特点：
1.外面的类加载的时候，静态内部类并不会加载
2.静态内部类只会被加载一次，而且加载过程是线程安全的

枚举的方式

enum Singleton7 {
    INSTANCE;
}

枚举里只有一个对象，天然就是单例的。

如果你想了解更多我对编程和人生的思考，请关注公众号：青云学斋