浅谈模式 - 单例模式

对于某个类，在进程级别只允许一个实例存在。当然还有多进程间共享单例（一般也不常用）或者线程级别的单例。

实现方式：

① 恶汉式（最常见，最简单）

public class Singleton {

    private static final Singleton INSTANCE = new Singleton();

    private Singleton() {
    }

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

② 懒汉式（双重检测，为防止指令冲排序，加上volatile）

public class DoubleCheck {
  
    private static volatile DoubleCheck INSTANCE;

    private DoubleCheck() {
    }

    public static DoubleCheck getInstance() {
        if (INSTANCE != null) {
            return INSTANCE;
        }

        synchronized (DoubleCheck.class) {
            if (INSTANCE != null) {
                return INSTANCE;
            }
            INSTANCE = new DoubleCheck();
            return INSTANCE;
        }
    }
}

③ 静态内部类（内部类是要在用到时候才加载）

public class StaticClass {

    private StaticClass() {
    }

    private static class Holder {
        private static final StaticClass INSTANCE = new StaticClass();
    }

    public static StaticClass getInstance() {
        return Holder.INSTANCE;
    }
}

④ 使用Enum来实现（反正我是没用过）

public enum SingletonEnum {
    INSTANCE,
    ;

    public void soSomething() {
        System.out.println("do something");
    }
}

这个设计模式应该谁都懂，没必要多说。细节的资料网上太多。在大部分情况，我会选择恶汉式的实现方式，因为简单嘛，不用动脑子。不过一般项目都会加入Spring，直接使用Spring的Singleton即可。除非要是技术框架开发，那就要看实际情况了。

查看全部 浅谈模式 - 汇总篇