单例模式五种写法与线程安全

懒汉式

是否 Lazy 初始化：是

是否多线程安全：可以实现

实现难度：易

优点：第一次调用才初始化，避免内存浪费。

缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。

单线程：

public class LazyMan {
    //线程不安全
    private LazyMan(){
    }
    
    private static LazyMan instance;
    
    public static LazyMan getInstance(){
        if (instance==null){
            instance = new LazyMan();
        }
        return instance;
    }
}

多线程：

public class LazyManSafe {
    //线程安全，但是锁占用资源
    private LazyManSafe(){
    }

    private static LazyManSafe instance;

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

饿汉式

是否 Lazy 初始化：否

是否多线程安全：是

实现难度：易

优点：没有加锁，执行效率会提高。

缺点：类加载时就初始化，浪费内存。

public class HungryMan {
    //线程安全，但是浪费资源空间
    private HungryMan(){
    }

    //注意加上final
    private static final HungryMan instance = new HungryMan();

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

它基于 classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。

双重锁/双重校验锁

JDK 版本：JDK1.5 起

是否 Lazy 初始化：是

是否多线程安全：是

实现难度：较复杂

public class DoubleCheck {

    private DoubleCheck(){
    }

    //注意加上volatile
    private volatile static DoubleCheck instance;

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

        return instance;
    }
}

1.双重判断的原因：

第一次：避免不必要的线程等待，相当于对多线程懒汉式的优化，提高效率

第二次：避免多次实例化，单例模式的基本检查

2.使用volatile的原因：

主要是禁止重排序，初始化一个实例（SomeType st = new SomeType()）在java字节码中会有4个步骤：

1、申请内存空间
2、初始化默认值（区别于构造器方法的初始化）
3、执行构造器方法
4、连接引用和实例

这4个步骤后两个有可能会重排序，1234或1243都有可能，造成未初始化完全的对象发布。volatile可以禁止指令重排序，从而避免这个问题。

3.为什么是JDK1.5起？

（待补充，大致是因为JVM虚拟机、volatile在jdk1.5前后有改变）

4.为什么synchronized保证有序性，却还要用volatile？

关于这个问题，可以参考知乎Java synchronized 能防止指令重排序吗？

静态内部类

是否 Lazy 初始化：是

是否多线程安全：是

实现难度：一般

//静态内部类
public class Holder {
    private Holder(){
    }

    static class InnerHolder{
        private static final Holder instance = new Holder();
    }

    public static Holder getInstance(){
        return InnerHolder.instance;
    }
}

只有第一次调用getInstance方法时，虚拟机才加载 内部类 并初始化 instance ，只有一个线程可以获得对象的初始化锁，其他线程无法进行初始化，保证对象的唯一性。目前此方式是所有单例模式中最推荐的模式，但具体还是根据项目选择。

如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面，又不希望在 Singleton 类加载时就实例化，因为不能确保 Singleton 类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance 显然是不合适的。这个时候，这种方式相比第 3 种方式就显得很合理。

枚举

JDK 版本：JDK1.5 起

是否 Lazy 初始化：否

是否多线程安全：是

实现难度：易

public enum Singleton {
    INSTANCE;
}

默认枚举实例的创建是线程安全的，并且在任何情况下都是单例。实际上

• 枚举类隐藏了私有的构造器。
• 枚举类的域 是相应类型的一个实例对象
  那么枚举类型日常用例是这样子的：

public enum Singleton  {
    INSTANCE 
 
    //doSomething 该实例支持的行为
      
    //可以省略此方法，通过Singleton.INSTANCE进行操作
    public static Singleton get Instance() {
        return Singleton.INSTANCE;
    }
}

这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。 这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。 不能通过 reflection attack 来调用私有构造方法。

结论：

一般情况下，不建议使用第 1 种懒汉方式，建议使用第 2 种饿汉方式。只有在要明确实现 lazy loading 效果时，才会使用第 4 种静态内部类方式。如果涉及到反序列化创建对象时，可以尝试使用第 5 种枚举方式。

对于第3种双重锁单例模式，本人认为加了volatile后应该解决了问题，可以算的上是一个线程安全、高效、懒加载的单例模式，但是搜索网上评论后大多都没有推荐这种方式，如有读者知道原因，请在评论区指出。