单例是设计模式中最经典最简单的设计模式，但是它却有至少七种实现方式，你真的会单例吗？

应用场景：只需要一个实例

  • 比如各种Mgr
  • 比如各种Factory

实现方式

基本思想：私有化构造函数，提供公共的静态方法getInstance获取实例，保证实例唯一性

1. 饿汉式：不使用也会在JVM装载类时占用资源

  • 使用final声明INSTANCE private static final Mgr02 INSTANCE

  • 声明时初始化实例 或 静态代码块中初始化实例

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

    private Mgr01() {};

    public static Mgr01 getInstance() {
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        Mgr01 m1 = Mgr01.getInstance();
        Mgr01 m2 = Mgr01.getInstance();
        System.out.println(m1 == m2);
    }
}

2. 懒汉式：线程不安全

  • 在获取前实例前，如果为空则初始化

    public class Mgr03 {
    private static Mgr03 INSTANCE;

    private Mgr03() {
    }

    public static Mgr03 getInstance() {
        if (INSTANCE == null) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Mgr03();
        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->
                System.out.println(Mgr03.getInstance().hashCode())
            ).start();
        }
    }
}

3. synchronized方法+懒汉式：效率降低

4. synchronized代码块+懒汉式：不可行

5. volatile+双重检查(DCL)：实现过于复杂

public class Mgr06 {
    private static volatile Mgr06 INSTANCE; //JIT

    private Mgr06() {
    }

    public static Mgr06 getInstance() {
        if (INSTANCE == null) {
            //双重检查
            synchronized (Mgr06.class) {
                if(INSTANCE == null) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new Mgr06();
                }
            }
        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr06.getInstance().hashCode());
            }).start();
        }
    }
}

6. 静态内部类：懒加载(JVM保证唯一性)

public class Mgr07 {

    private Mgr07() {
    }

    private static class Mgr07Holder {
        private final static Mgr07 INSTANCE = new Mgr07();
    }

    public static Mgr07 getInstance() {
        return Mgr07Holder.INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr07.getInstance().hashCode());
            }).start();
        }
    }
}

7. 枚举：不仅可以解决线程同步，还可以防止反序列化

public enum Mgr08 {

    INSTANCE;

    public void m() {}

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr08.INSTANCE.hashCode());
            }).start();
        }
    }
}

总结

单例设计模式存在多种实现方式，深入研究好似孔乙己的“回”字不同写法，作为一个实用的程序员，不要忘了设计模式的初衷。

实用主义的经验：饿汉式适用于大部分问题场景，静态内部类是相对直观且完美的实现方式。volatile+DCL属于学术派，不是好的设计，但是很好的研究JVM内部机制的场景。

参考资料：

马士兵老师-设计模式