单例模式的4种实现

单例模式（懒汉式和饿汉式）

懒汉式

懒汉式模式，简单来说就是懒，可以看到声明静态singleton 的时候没有实例化new 出来，而是先赋值null,等到你要用到对象的时候才会new。

public class Singleton {
    //首先声明为私有的构造函数是防止这个类被new，毕竟单例模式只能存在一个对象，所以我们使用的时候不能 new
    private Singleton(){

    }
    //声明为静态变量保证内存只存在一份
    private static Singleton singleton  = null;

    public static Singleton getSingleton(){
        //只有第一次调用静态方法获取对象的时候才会new
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

性能：较低（当前类在加载的时候对象先没有实例化好，而是到真正使用才实例化）
内存消耗：较少（只用用到的时候才去new,没用到就不new）
线程安全：否

 if(singleton == null){//线程B执行到这里
   singleton = new Singleton();//线程A 执行到这里，已经new 了对象，但是对象地址还没有来得及赋值给singleton，此时不巧线程B 刚好执行到singleton == null，发现条件满足也就进来了，此时会new 两次对象。
  }

为什么线程不安全呢？看看上面的if代码块就知道了，比如当前有两个线程正在调用Singleton.getSingleton() 获取对象时，会有可能new 出两个对象。

懒汉式（加锁）

直接加了synchronized 同步锁，此时最多只有一个线程在使用getSingleton（）。所以不会出现线程不安全情况。

public class Singleton {
    //首先声明为私有的构造函数是防止这个类被new，毕竟单例模式只能存在一个对象，所以我们使用的时候不能 new
    private Singleton(){

    }
    //声明为静态变量保证内存只存在一份
    private static Singleton singleton  = null;

    public static synchronized Singleton getSingleton(){
        //只有第一次调用静态方法获取对象的时候才会new
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

性能：更低（当前类在加载的时候对象先没有实例化好，而是到真正使用才实例化，还加了同步锁会影响性能）
内存消耗：较少（只用用到的时候才去new,没用到就不new）
线程安全：是

饿汉式

饿汉式，一开始就实例化好对象，在类加载就已经实例化好了。

public class Singleton {
    //首先声明为私有的构造函数是防止这个类被new，毕竟单例模式只能存在一个对象，所以我们使用的时候不能 new
    private Singleton(){

    }
    //声明为静态变量保证内存只存在一份
    private static Singleton singleton  = new Singleton();

    public static Singleton getSingleton(){
        return singleton;
    }
}

饿汉式不用加锁也能保证线程安全，因为它在类一开始加载就实例化了对象，getSingleton（）方法里没有new 对象，所以你调用多少次getSingleton（）都还是一开始生成的那对象。

性能：高（首先不加同步锁性能提高了，其次对象在类加载时候已经事先new 好了，用到直接getSingleton（）获取就行了，不必再new）
内存消耗：较大（在类一加载就实例化对象，不管你用不用到这个对象我都new 出来，这样内存消耗大）
线程安全：是

双检锁/双重校验锁

ublic class Singleton {

    //首先声明为私有的构造函数是防止这个类被new，毕竟单例模式只能存在一个对象，所以我们使用的时候不能 new
    private Singleton (){

    }
    //声明为静态变量保证内存只存在一份
    //还加了volatile 避免重排序
    private volatile static Singleton singleton;

    public static Singleton getSingleton() {
        if (singleton == null) {
            /*
            由于加synchronized 会影响性能，所以在用synchronized之前加了
            个判断if (singleton == null),这样就不必每次就会调用synchronized
             */
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

new 一个对象可以分3步骤
memory = allocate();　　// 1：开辟一块内存
ctorInstance(memory);　// 2：初始化
instance = memory;　　// 3：把内存地址返回

步骤2和3可能是反着
memory = allocate();　　// 1：开辟一块内存
instance = memory;　　// 2：把内存地址返回
ctorInstance(memory);　// 3：初始化
这就出现重排序问题，这样导致明明线程A已经new Singleton();但是线程B在 (singleton == null) 的时候判断是空。所以两个线程都可能对进来。
加volatile 关键字可以避免重排序。

OK 先总结到这里，渣渣水平，有错误欢迎指出。