单例模式

单例模式是最简单的设计模式之一，它在内部限制了该类只能创建一个唯一对象，并只提供了一种访问其唯一对象的方式，外部可以直接访问，不需要再去实例化该类的对象。

1.饿汉式

特点：类加载的时候生成对象，无论有没有使用，类加载的时候都占用了时间和内存，但是使用时速度快，线程安全。

public class Singleton1 {
    /**
     *饿汉式
     */
    private static Singleton1 instance=new Singleton1();
    private Singleton1(){}
    public static Singleton1 getInstance(){
        return instance;
    }
}

2.懒汉式

特点：第一次使用的时候才生成对象，在使用速度和内存上面达到了兼顾，比较平衡，但是线程不安全。

public class Singleton2 {
    /**
     * 懒汉式
     */
    private static Singleton2 instance;
    private Singleton2(){}
    public static Singleton2 getInstance(){
        if(instance==null){
            instance=new Singleton2();
        }
        return instance;
    }
}

3.懒汉式增强版

特点：继承了懒汉式的优点，而且线程安全，但是每次获取对象都要上锁，影响了效率。

public class Singleton3 {
    /**
     * 懒汉式增强版（线程安全）
     */
    private static Singleton3 instance;
    private Singleton3(){}
    public static synchronized Singleton3 getInstance(){
        if(instance==null){
            instance=new Singleton3();
        }
        return instance;
    }
}

4.双重校验锁机制

特点：可以在保证线程安全的情况下面保证高效率，但是现实起来相对复杂。

public class Singleton4 {
    /**
     * 双重校验锁机制
     */
    private static volatile Singleton4 instance;
    private Singleton4(){}
    public static Singleton4 getInstance(){
        if(instance==null){
            synchronized (Singleton4.class){
                if(instance==null){
                    instance=new Singleton4();
                }
            }
        }
        return instance;
    }
}

第一次使用 if(instance==null) 是为了提高代码执行效率，如果不为null则直接返回实例对象。

第二次使用 if(instance==null) 是为了防止多线程情况下重复构建实例。假如有一种情况，当instance还没有被创建的时候，线程 t1调用了getInstance方法，第一次判断了instance==null，此时 t1准备继续执行，但是正好这个时候资源被线程 t2抢占了,此时 t2也调用了getInstance方法，此时instance==null，于是通过第一层和第二层的校验，创建了instance对象；之后当t1继续执行的时候如果没有第二层的if(instance==null)的判断的话，它会继续创建一个instance对象，这样就重复构建实例了，所以需要一个双重校验锁。

private static volatile Singleton instance 中的 volatile的作用是为了防止jvm 的指令重排。

创建一个对象 instance=new Singleton（）这句代码这分为三步：
1.为 instance 分配内存空间 ;
2.初始化 instance ;
3.将 instance 指向分配的内存空间 。
由于 JVM 具有指令重排的特性，执行顺序可能重排为1-3-2，在单线程情况下不会出现问题
，但是在多线程下会导致一个线程获取到一个未初始化的实例对象。
例如：线程 t1 执行了 1 和 3 ，此时线程 t2 调用getInstance() 之后发现 instance 不为空，于是就返回了 instance ，但是实际上 instance 还没有被初始化。
使用了 volatile关键字之后就会禁止 JVM 的指令重排，从而可以保证在多线程的情况下也可以正常的执行。

volatile关键字的第二个作用，保证变量在多线程运行时的可见性：

在 JDK1.2 之前，Java的内存模型实现总是从主存（即共享内存）读取变量，是不需要进行特别的注意的。而在当前 的 Java 内存模型下，线程可以把变量保存本地内存（比如机器的寄存器）中，而不是直接在主存中进行读写。这就 可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成数 据的不一致。 要解决这个问题，就需要把变量声明为 volatile，这就指示 JVM，这个变量是不稳定的，每次使用它都到主存中进行 读取。