设计模式：单例模式

摘要：常规设计模式之单例模式

前言

设计模式作为我们开发人员必不可少的编程思想，我们有必要好好的去学习、理解和掌握。今天开始我会整理自己所有学习过和没有学习过的设计模式，希望大家一起多多交流。

这一章主要介绍我们常用的单例模式，它解决了我们需要反复获取那些占用较大资源和开销的对象的问题。并且单例出来的对象往往持有我们需要的一些状态供我们使用。

单例分类

1. 饿汉式

饿汉式单例模式是基于classloder机制避免了多线程的同步问题。但是，instance在类装载时就会实例化，这时候初始化instance是没有达到lazy loading的效果的。

public final class HungrySingleton {

    /* 还有一种方式是在静态代码块中进行demo的初始化，但是在
        多线程操作时，会出现空引用问题。
    */
    private static final HungrySingleton demo = new HungrySingleton();
    
    private HungrySingleton(){}

    public static HungrySingleton getInstance(){
        return demo;
    }
}

2. 懒汉式

线程不安全的懒汉式，实例化方法在多线程访问时可能出现多实例，测试时出现多实例的概率虽然小，但是线程不安全

public final class LazyLoadingUnSafety {

    private static LazyLoadingUnSafety lazyLoading;

    private LazyLoadingUnSafety(){}

    public static LazyLoadingUnSafety getInstance(){
        if (lazyLoading == null){
            lazyLoading = new LazyLoadingUnSafety();
        }
        return lazyLoading;
    }
}

线程安全的懒汉式

public final class LazyLoadingSafe {

    private static LazyLoadingSafe lazyLoading;

    private LazyLoadingSafe(){
        // 避免通过反射进行实例的初始化
        if (lazyLoading == null) {
            lazyLoading = this;
        } else {
            throw new IllegalStateException("Already initialized.");
        }
    }

    /**
     * 通过synchronized 关键字进行实例化方法的线程安全
     * @return LazyLoadingSafe 返回的单实例
     */
    public static synchronized LazyLoadingSafe getInstance(){
        if (lazyLoading == null){
            lazyLoading = new LazyLoadingSafe();
        }
        return lazyLoading;
    }

}

3. 静态内部类

利用了classloder的机制来保证初始化instance时只有一个线程，虚拟机会保证一个类的类构造器clinit()在多线程环境中被正确的加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的类构造器clinit()，其他线程都需要阻塞等待，直到活动线程执行clinit()方法完毕。

public final class InnerClassSingleton {

    private InnerClassSingleton(){}

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

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

4. 枚举单例

枚举形式单例，解决多线程和能防止反序列化重新创建新的对象的单例模式, 此方式是线程安全的，但是添加其他方法就需要开发者去自己保证方法的线程安全。

public class EnumSingleton {

    private int tickets = 1000;

    private EnumSingleton(){}

    public static EnumSingleton getInstance(){
        return Singleton.SINGLETON.getInstance();
    }

    // 线程不安全
    public int getTickets(){
        return tickets++;
    }
    
    enum Singleton {

        SINGLETON;

        private EnumSingleton enumSingleton;

        Singleton() {
            this.enumSingleton = new EnumSingleton();
        }

        private EnumSingleton getInstance(){
            return this.enumSingleton;
        }
    }

5. 双重检索单例

通过在实例化方法中增加锁进行线程安全保护，而实例变量singleton需要通过volatile关键字防止实例化方法在执行时进行指令重排出现线程安全问题。

public final class DoubleLockSingleton {

    // 不使用volatile 可能发生指令重排导致socket没有被初始化完毕报空指针异常
    private static volatile DoubleLockSingleton singleton;

    private Socket socket;

    private DoubleLockSingleton(){

        // 此处阻止通过反射实例化实例
        if (singleton != null) {
            throw new IllegalStateException("Already initialized.");
        }
        this.socket = new Socket();
    }

    public static DoubleLockSingleton getInstance(){

        // 避免每次进入都需要进入同步代码块，提高效率
        if (singleton == null){
            synchronized(DoubleLockSingleton.class){
                if (singleton == null) {
                    singleton = new DoubleLockSingleton();
                }
            }
        }
        return singleton;
    }
}

6. CAS 线程安全单例

最新学习的单例实现方式，主要通过java提供的cas机制保证去实例化对象的时候为最新对象。

public class CASSingleton {

    private static final AtomicReference<CASSingleton> INSTANCE = new AtomicReference<>();

    public CASSingleton() {
    }

    public static final CASSingleton getInstance() {
        for (;;) {
            CASSingleton currentInstance = INSTANCE.get();

            if (currentInstance != null) {
                return currentInstance;
            }

            currentInstance = new CASSingleton();

            if (INSTANCE.compareAndSet(null, currentInstance)) {
                return currentInstance;
            }
        }
    }

总结

单例模式在我们日常开发代码中会大量使用，即使没有自己经常去创建单例，但在我们所使用的各种框架中被大量，比如spring等。这种模式值得我们好好去总结与学习。

还看到一篇文章使用ThreadLocal进行单例模式的设计，但是在我目前的知识体系中，ThreadLocal为每个线程提供变量的一个副本，也就是我们存到ThreadLocal中的对象会以副本的形式被每个线程使用，最终的测试结果是不同线程使用的对象是不一致的，我个人认为这种单例she设计不太合理，各位大佬可以提提意见。

public class ThreadLocalSingleton {

    private static final ThreadLocal<ThreadLocalSingleton> local = ThreadLocal.withInitial(() -> new ThreadLocalSingleton());

    private ThreadLocalSingleton(){
    }

    public static ThreadLocalSingleton getInstance(){
        return local.get();
    }
}

Github地址：详细代码可以参考我的GitHub，谢谢大佬指正