单例模式

饿汉模式

public class Singleton {

    private static Singleton singleton  = new Singleton();

    private Singleton() {
    }
    public static Singleton getInstance(){
        return singleton;
    }
}

此方法能保证singleton唯一性，但一起动则初始化，如果有大量的动作，那么会极为耗费性能，所以引申出懒汉模式。

懒汉模式

public class Singleton {

    private static volatile Singleton singleton;

    private Singleton() {
    }
    public synchronized static Singleton getInstance(){
        if (singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

此方法能保证唯一性，而且系统初始化时也不会耗费性能，只有第一次调用才会耗费性能，但由于使用了synchronized，所以getInstance方法效率很低。

DCL单例模式

懒汉模式是这样的

/**
 * 普通的单例模式
 * @author
 */
public class Singleton {

    private static Singleton singleton;

    private Singleton(){}

    private synchronized static Singleton getInstance(){
        if (singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

又或者是这样的

 private static Singleton getInstance(){
        synchronized(Singleton.class){
            if (singleton == null){
                singleton = new Singleton();
            }
            return singleton;
        }
    }

但实质上synchronized放在方法上和代码块上的作用对于同步而言是一样的，都是使其包裹区域同一时间内只有一个线程可以运行(这是原子性)，但是我们细心观察发现，我们其实需要保证同步的代码只有“singleton = new Singleton()”这一行代码，而且我们synchronized会造成性能损耗，那么对于这种情况，我们应该有更好的方法，那么就到了我们的DCL(double check locking)单例模式

DCL单例模式

 private static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.singleton) {	// flag1
                if (singleton == null){				// flag2
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }

这样以后，只有第一个初始化的时候才会进入同步代码块，如果第一次初始化有thread1和thread2执行到flag1代码后，thread1释放完锁后thread2进入并不会再次new实例，这就保证了唯一性

这样看似很完美，但事实并不如此，我们先来看singleton = new Singleton被编译为指令后做了什么操作，做了三步操作：

1、给singleton实例分配内存
2、执行初始化构造方法
3、将instance指向了实际分配的内存空间。

注意，在3这一步的时候因为singleton引用指向了实际的内存空间，所以它不为null了

但jvm指令重拍会造成一个情况，会造成2和3的顺序重排，原因是为了优化指令，所以实际上的指令顺序是这样的

1、给singleton实例分配内存
3、将instance指向了实际分配的内存空间
2、执行初始化构造方法

然后当执行3完后，如果有另一个线程此时调用getInstance方法，那么第一行的判断则不成立，会返回singleton，此时返回的singleton是未初始化完的，那么使用肯定会报错“实例未初始化”，为解决此问题则引入一个volatile关键字，此关键字修饰的变量不会被指令重排(这是有序性,除此之外volatile还保证了可见性)，注意volatile修饰的变量不会被指令重排，但其他的代码会被指令重排，但指令重排不会影响被volatile修饰的变量的代码顺序

所以使用volatile修饰

private static volatile Singleton singleton;

完整代码如下

public class Singleton {

    private static volatile Singleton singleton;

    private Singleton() {
    }

    private static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.singleton) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

最后做个总结：单例模式最初有饿汉懒汉的区分，但懒汉由于一般使用synchronized代码块修饰导致性能降低，所以我们更改了synchronized的位置保证只影响第一次初始化时的性能，然后又由于jvm指令重排的问题，我们引入了volatile关键字

我们思考一下，能不能使用其他的方法来实现第一次调用时才加载，且不使用synchronized机制呢？答案很显然有，就是Holder单例模式，它使用了静态内部类的方法

Holder单例模式

DCL是为了解决懒汉模式中存在的性能问题，但它的代码逻辑有些许复杂，我们可以用更简单的方式来实现

public class Singleton {

    private static class InSingleton{
        private static InSingleton inSingleton = new InSingleton();
    }

    public static InSingleton getInstance(){
        return InSingleton.inSingleton;
    }
}

为什么这个能保证唯一性，且能保证延时加载，为啥呢？

首先是延时加载的问题：

当我们的系统启动时Singleton被JVM加载，但此时我们内部类InSingleton并没有被加载，这是延时加载，当getInstance方法被调用的时候，InSingleton就被初始化了

然后是唯一性问题：

jvm解释中，虚拟机会保证一个类的init方法被正确的加锁，当多个线程同时去init的时候，只有一个线程会进入init方法，其他线程则会被阻塞，这就保证了唯一性

虽说Holder看起来是比较完美的单例模式，既解决了延时加载，也解决了唯一性安全的问题，但由于是内部类创建的实例，所以如果你想创建实例的时候根据传入参数来创建的话，那么是无法完成的，所以根据这一点来说，DCL和Holder自行评估使用

枚举单例模式

public enum SingletonEnum {
    /**
     * 需要的对象
     */
    INSTANCE
}

枚举单例模式特别简洁，且里面同样可以拥有属性方法(因为编译后枚举也是一个类，只是继承与Enum)，且同样能保证唯一性，还有防止序列化和反射的不一致情况，具体可百度，太多不想写了