五种单例模式

在整个程序中，保持只有一个实例对象，就是单例模式。

单例模式可以减少构建，GC的次数，提升性能，还能减少堆内存的开销。

1. 懒汉式

• 在需要使用对象的时候，才进行创建

• 通过private构造方法，确保外部不能new出对象，通过一个静态方法进行对象获取。

public  class LazySingleton implements Serializable {
    private static LazySingleton lazySingleton = null;

    private  LazySingleton() {
    }

    public  static LazySingleton  getInstance(){
        if(lazySingleton == null){
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }
}

 需要注意的是，懒汉式是线程不安全的，并发情况下有线程安全问题，需要进行同步处理。

可以在getInstance()方法上加上synchronized。但是锁的粒度很大，所以引出了双重检查锁

2. 双重检查锁

• 通过两个if判断,加上同步锁进行实现
• 只进行一次判断上锁的话，上锁解锁后，单例对象就被重置了，因为有可能多个线程同时都通过了第一次判断，只是没抢到锁
• 而且，需要加上volatile保证可见性和同步性，因为锁住的是class对象，不是单例对象，所以JMM保证的unlock刷到主存，lock读到工作内存只对class对象起作用，单例对象的可见性无法保证，同样的，是class对象的unlock操作在lock操作之前，happens before原则也无法保证有序性，因为整个临界区内根本找不到一个和class对象相关的操作。

public class DoubleCheckSingleton {
    private static volatile  DoubleCheckSingleton doubleCheckSingleton ;
    private DoubleCheckSingleton(){

    }

    public static DoubleCheckSingleton getInstance(){
        if(doubleCheckSingleton ==null){
            synchronized (DoubleCheckSingleton.class){
                if (doubleCheckSingleton == null){
                    doubleCheckSingleton = new DoubleCheckSingleton();
                }
            }
        }

        return doubleCheckSingleton;
    }
}

 3. 静态内部类

双重检查锁对于同步控制特别的复杂繁琐，有没有什么底层已经进行了的同步操作可以利用的呢？

答案是类加载的loadclass是被synchronized修饰的，类的加载是同步的，类加载进行到初始化部分的时候会对静态变量赋初始值，也会执行静态代码块。

• 在单例类中,通过私有的静态内部类,创建单例对象

• 静态内部类只有在被调用的时候才会被加载，实现了懒加载。

public class StaticInnerClassSingleton {

    /**
     * 第一次被调用到的时候才会进行类加载，进行初始化（JVM相关知识，加载、连接（验证，准备，解析）、初始化（为静态变量赋值）
     */
    private static class InnerClass{
        private static final StaticInnerClassSingleton staticInnerClassSingleton = new StaticInnerClassSingleton();
    }

    private StaticInnerClassSingleton(){
        System.out.println("StaticInnerClassSingleton初始化......");
    }

    public static StaticInnerClassSingleton getInstance(){
        return InnerClass.staticInnerClassSingleton;
    }
}

4. 饿汉式

如果不追求懒加载，那么还是使用类加载的同步控制的话，直接在单例类放一个静态变量，或者在静态代码块进行初始化。

public class HungrySingleton {

    private static final HungrySingleton hungrySingleton ;
    static {
        hungrySingleton = new HungrySingleton();
    }

    private HungrySingleton(){
        System.out.println("HungrySingleton初始化.....");
    }

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

5. 枚举

前面一步一步的推导出到了饿汉式，看着很完美了，但是单例模式会被反射破坏。通过反射获取到构造函数后，可以强制开启权限执行。序列化和反序列化也都是基于反射创建对象的。

那么什么单例模式不会有这样的情况呢？

枚举。枚举是最佳的单例模式实现方式。

枚举在底层的构造函数是强制private的，反射无法打开权限，枚举对象的反序列化是通过name在堆内找到对应的对象

public enum EnumSingleton implements Serializable {
    EnumSingleton("枚举单例");

    private String name;

    EnumSingleton() {
    }

    EnumSingleton(String name) {
        this.name = name;
    }

    public void doSomething(String something) {
        System.out.println(name + ":" + something);
    }
}