JAVA设计模式--单例模式

背景

单例模式，属于创建类型的一种常用的软件设计模式。通过单例模式的方法创建的类在当前进程中只有一个实例。
根据需要，也有可能这个单例属于一个线程，如：ThreadLocal,仅线程上下文内使用同一个实例。
通常来说，单例模式又分为饿汉式、懒汉式、静态内部类、双重校验锁、枚举五钟类型。
除此之外，本文中还举例了一种其他的单例实现方式，如，通过TheadLocal。

适用场景

• 需要频繁的进行创建和销毁的对象；
• 创建对象时耗时过多或耗费资源过多，但又经常用到的对象；
• 工具类对象；
• 频繁访问数据库或文件的对象。

饿汉式

这种写法比较简单，就是在类装载的时候就完成实例化。

public class HungerSingleInstance {
    private static HungerSingleInstance instance = new HungerSingleInstance();

    public HungerSingleInstance() {}

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

优点：天然的保证了线程的安全，不用担心并发问题，因为它在你类加载的时候就把对象实例化好了。
缺点：类加载时就初始化，浪费内存，因为这个类你有可能一直没有用到。

懒汉式

public class LazySingleInstance {

    private  static LazySingleInstance instance;

    public LazySingleInstance() { }

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

优点：实现类只有在需要的时候被加载，不浪费内存空间。
缺点：效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步，99% 情况下不需要同步。

双重校验锁

对于多线程开发者来说不会陌生，如代码中所示，通过进行了两次if (singleton == null)检查，保证了线程安全。这样，实例化代码只用执行一次，后面再次访问时，判断if (singleton == null)，直接return实例化对象。

public class SingleInstance {
    private volatile static SingleInstance instance;
    public SingleInstance() {
    }

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

优点：这种方式采用双锁机制，按需加载，安全且在多线程情况下能保持高性能。

静态内部类

这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。

public class StaticInnerSingleInstance {
    private static class SingleInstance{
        private static final StaticInnerSingleInstance instance = new StaticInnerSingleInstance();
    }

    public StaticInnerSingleInstance() { }

    public static StaticInnerSingleInstance getInstance(){
        return SingleInstance.instance;
    }
}

这种方式跟饿汉式方式采用的机制类似，但又有不同。两者都是采用了类装载的机制来保证初始化实例时只有一个线程。不同的地方在饿汉式方式是只要Singleton类被装载就会实例化，没有Lazy-Loading的作用，而静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。
优点：实现简单，线程安全且在多线程情况下能保持高性能。

枚举

不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。可能是因为枚举在JDK1.5中才添加，所以在实际项目开发中，很少见人这么写过。

public enum Singleton {
    INSTANCE;
    public void whateverMethod() {
    }
}

优点：它更简洁，线程安全，而且自动支持序列化机制，绝对防止多次实例化。

ThreadLocal

ThreadLocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。

public class Singleton {

    private static final ThreadLocal<Singleton> tlSingleton = new ThreadLocal<Singleton>() {
        @Override
        protected Singleton initialValue() {
            return new Singleton();
        }
    };

    private Singleton() {}

    public static Singleton getInstance() {
        return tlSingleton.get();
    }
    
}

参考：https://zhuanlan.zhihu.com/p/150004430