单例模式的六种实现方式

1. 懒汉式单例模式

• 优点：使用时再加载对象，空间资源利用效率高
• 缺点：{@code getInstance}方法需要同步，并发效率低

class Singleton1{
    private Singleton1(){}
    private static Singleton1 instance = null;

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

2.饿汉式单例模式

• 优点：类加载过程是线程安全的，对象在类加载过程中实例化，因此也是线程安全的
• 缺点：没有使用对象时对象已经创建，消耗空间资源

class Singleton2{
    private static Singleton2 instance = new Singleton2();
    private Singleton2(){}
    public static Singleton2 getInstance(){
        return instance;
    }
}

3.双重检测锁式单例模式

• volatile关键字的一个作用是禁止指令重排，把instance声明为volatile之后，
• 对它的写操作就会有一个内存屏障（什么是内存屏障？），这样，在它的赋值完成之前，就不用会调用读操作。
  注意：volatile阻止的不singleton = newSingleton()这句话内部[1-2-3]的指令重排，
• 而是保证了在一个写操作（[1-2-3]）完成之前，不会调用读操作（if (instance == null)）。

class Singleton3{
    private Singleton3(){}
    private static volatile Singleton3 instance = null;

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

4.枚举式单例模式

• 优点：枚举类由JVM保证是单例，且无法被反射机制破解（其他4种单例模式的实现都可以被反射机制调用私有构造方法）
• 缺点：类加载时就实例化，占用空间资源

enum SingletonEnum4{
    INSTANCE;
    public void get(){}
}

5.静态内部类式单例模式

• 优点：静态内部类的加载也是天然线程安全的，且不会在外部类加载时加载，
• 因此静态内部类式单例模式兼备并发高效率和延迟加载节省空间资源的优势

class SingletonStaticInnerClass5{
    private static class SingletonClassInstance {
        private static final SingletonStaticInnerClass5 instance= new SingletonStaticInnerClass5();
    }
    private  SingletonStaticInnerClass5(){}
    public static SingletonStaticInnerClass5 getInstance(){
        return SingletonClassInstance.instance;
    }

}

6.ThreadLocal

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

class Singleton6{
    private Singleton6(){}
    private static final ThreadLocal<Singleton6> instance =
            new ThreadLocal<Singleton6>(){
                @Override
                protected Singleton6 initialValue(){
                    return new Singleton6();
                }
            };

    public static Singleton6 getInstance(){
        return instance.get();
    }

}