单例模式实现_单例模式对比-CSDN博客

本文详细介绍了Java中的六种单例模式实现方式，包括饿汉式、懒汉式、线程安全单例、双重校验锁、内部类单例和枚举单例。每种方式都有其优缺点，例如饿汉式和懒汉式分别在初始化时机和线程安全性上存在差异，而双重校验锁和内部类单例则在性能和防止反射、反序列化破坏单例方面做了改进。最后，文章指出枚举单例是最安全且推荐的实现方式，因为它能防止所有可能破坏单例的途径。

单例模式对比

1.饿汉试单例
2.懒汉试单例
3.线程安全单例
4.双重校验线程安全单例
5.内部类单例
6.枚举单例

1.饿汉试单例

public class EagerInitializedSingleton {
    private EagerInitializedSingleton() {}
    private static EagerInitializedSingleton instance = new EagerInitializedSingleton();

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

恶汉试单例模式，很简单，就是利用静态变量，在运行过程中只会加载一次的特点，一般简单的场景，足够使用，但是存在如下问题：没有使用到该单例的时候，已经把该类加载到内存，占用内存空间。

2.懒汉试单例

public class LazyInitializedSingleton {
    private LazyInitializedSingleton(){}
    private static LazyInitializedSingleton instance;
    public static LazyInitializedSingleton getInstance(){
        if (instance == null){
            instance = new LazyInitializedSingleton();
        }

        return instance;
    }
}

为了解决恶汉试单例问题，出现了懒汉试单例模式，只有在使用的时候，再将其加载到内存。但是懒汉试单例，也存在着一个严重的问题：线程安全的问题。

3.线程安全单例

public class SafetyLazyInitializedSingleton {
    private SafetyLazyInitializedSingleton() {}
    private static SafetyLazyInitializedSingleton instance;
    public static synchronized SafetyLazyInitializedSingleton getInstance(){
        if (instance == null){
            instance = new SafetyLazyInitializedSingleton();
        }

        return instance;
    }
}

为了解决懒汉式线程安全的问题，出现线程安全的单例模式，也就是在获取单例的地方，加上锁。这个也有一个严重的问题，单例创建之后，每次获取单例模式都要获取锁，降低了代码的性能。

4.双重校验线程安全单例

public class DoubleCheckSafetyLazyInitializedSingleton {
    private DoubleCheckSafetyLazyInitializedSingleton(){}
    private static DoubleCheckSafetyLazyInitializedSingleton instance;
    private static final Object locker = new Object();
    public static DoubleCheckSafetyLazyInitializedSingleton getInstance(){
        if (instance == null){
            synchronized (locker){
                if (instance == null){
                    instance = new DoubleCheckSafetyLazyInitializedSingleton();
                }
            }
        }

        return instance;
    }
}

为了解决上述的问题，使用了双重校验，只有单例没有创建的时候，才需要使用锁住。单例创建之后，便不经过锁。这种模式，还是有问题，就是单例通过反序列、反射可以破坏该类的单例模式。

5.内部类单例

public class InnerClassSingleton {
    private InnerClassSingleton(){}
    private static class InnerClassSingletonHolder{
        private static InnerClassSingleton instance = new InnerClassSingleton();
    }

    public static InnerClassSingleton getInstance(){
        return InnerClassSingletonHolder.instance;
    }
}

内部类单例实现的效果和双重检验线程安全单例，类似，但是比其简单，易懂。这种模式，还是有问题，就是单例通过反序列、反射可以破坏该类的单例模式。

6.枚举单例

public enum EnumSingleton {
    INSTANCE;

}

单例模式，解决了反射、反序列化破坏单例模式的情况。所以正在的单例模式，应该是枚举单例。