单例模式

单例模式(Singleton)是一种常用的设计模式，顾名思义，单例就是在整个系统中，指定一个类只存在一个实例化对象。

单例的创建方式

• 饿汉式，即类被加载后，就创建当前类的一个实例，不管这个类是否使用到。

public class Singleton {
    //私有化一个实例对象
    private static final Singleton INSTANCE = new Singleton();
    //私有构造方法，使其它类无法创建当前类的实例，保证唯一性
    private Singleton(){}
    //公共方法，返回实例化对象的引用，其它类只有通过此方法获取当前类的实例，并且获得的都是同一个对象
    public static Singleton getInstance(){
        return INSTANCE;
    }
}

饿汉式是最简单的写法，同时也保证了线程安全(由虚拟机保证)，类加载的时候，就实例化了一个对象。

• 懒汉式，即类被使用到的时候，才去创建这个类的对象。

public class Singleton {
    //创建一个指向空的引用，不进行初始化
    private static Singleton INSTANCE = null;
    
    private Singleton(){}
    
    public static Singleton getInstance(){
        //判断是否实例化，没有就创建一个对象
        if (INSTANCE == null){
            INSTANCE = new Singleton();
        }
        return INSTANCE;
    }
}

懒汉式的这种写法是存在线程不安全的，当多线程访问getInstance()方法时，若线程1进入if块中，但还没有创建对象，此时线程2也进入getInstance()方法，它去判断INSTANCE是否是空，发现还是没有实例化，所以它也进入了if块里。这样线程1和线程2都会去实例化，创建的也就是两个对象了。

解决上面的问题，就需要使用synchronized关键字，给方法加锁，保证同一时刻只有一个线程进入getInstance()方法中

public class Singleton {
    private static Singleton INSTANCE = null;

    private Singleton(){}
    //使用synchronized加锁
    public static synchronized Singleton getInstance(){
        if (INSTANCE == null){
            INSTANCE = new Singleton();
        }
        return INSTANCE;
    }
}

但是synchronized虽然保证线程安全，但同样带来效率下降的问题。

所以可以将实例化对象的代码用synchronized块包住，这样性能上比直接使用synchronized锁住getInstance()更优

public class Singleton {
    private static Singleton INSTANCE = null;

    private Singleton(){}

    public static Singleton getInstance(){
        if (INSTANCE == null){
            //使用synchronized同步块
            synchronized(Singleton.class){
                INSTANCE = new Singleton();
            }
        }
        return INSTANCE;
    }
}

但是上面的写法虽然性能变优了，可是它却是线程不安全的，原因在于，会存在线程1和线程2先后进入if块中，此时线程1持有锁，然后线程1创建了一个对象后释放锁，而线程2在if块中，所以它自然地持有锁，也创建另一个对象。即if的判断和实例化过程被分开了，没有同步统一起来。

所以就有了双重检查

public class Singleton {
    //使用volatile来禁止指令重排
    private static volatile Singleton INSTANCE = null;

    private Singleton(){}

    public static Singleton getInstance(){
        if (INSTANCE == null){
            synchronized(Singleton.class){
                //双重检查
                if (INSTANCE == null){
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }
}

这里使用volatile是为了禁止JVM指令重排。

简单的讲，是创建一个对象时，首先向内存申请一块空间，其次调用类的构造方法，最后是将引用和对象建立联系。指令重排意味着可能后两步顺序颠倒，即先建立联系，再调用构造方法。若这个类有将其它类作为成员变量，会出现其它线程使用这个对象的成员变量还是null的情形。

所以最后懒汉式的标准写法是使用静态内部类

public class Singleton {
    private Singleton(){}
    //静态内部类
    private static class HoldSingleton {
        //实例化对象
        private static final Singleton INSTANCE = new Singleton();
    }
    
    public static Singleton getInstance(){
        return HoldSingleton.INSTANCE;
    }
}

一方面和饿汉式一样，由JVM保证线程安全，即只有类加载时实例化一个对象。另一方面是，外部类加载时，不会直接加载内部类，由此实现懒汉式的需求。

• 枚举单例

创建单例更完美的写法是使用枚举，主要是在线程安全上，还解决了反序列化，原因是枚举没有构造方法，可以防止反序列化，即无法通过反射来实例化新的对象。

public enum Singleton {
    INSTANCE;
    
    public Singleton getInstance(){
        return INSTANCE;
    }
}