2.单例设计模式

1.饿汉式

public class Single {
    private static Single instance = new Single();
    private Single(){
    }
    public Single getInstance(){
        return  instance;
    }
} 

2.懒汉式

2.1方法上加锁(性能不好）

public class Singleton {

    private static volatile Singleton singleton = null;

    private Singleton() {
        System.out.println("Singleton init...");
    }

    //No.1通过加synchronized保证线程安全
    public static synchronized Singleton getInstance1() {
        if (singleton == null) singleton = new Singleton();
        return singleton;
    }

}

2.2DCL双重加锁

有必要解释一下，volatile在这里主要防止指令重排序；第一个if (single == null)首先判断single为null否，主要是为了第二次访问不为空的时候，不需要进入同步代码块，效率提高；synchronized同步代码块里，服务于第一次访问，如果有多路竞争，只有一个能进入同步代码块，保证了线程的安全性，使其能安全的创建对象，然后返回；

还有一点非常重要：为什么要有第二个single == null:
我们假如没有这个这句话，线程A和线程B同时争夺这个锁，线程B获取锁成功，进入同步代码块new对象，完成后返回，这时候线程A获取到了锁，然后会再次new这个对象并且赋值，这时候，这个单例便被new了两次，出错；如果加上single == null，下次B成功new之后，线程A进入同步代码块，会发现这时候single不为null，直接不做任何事情，返回single；

注意这里的volatile也非常重要：如果不加volatile关键字，会发生指令重排序，假如虚拟机在执行single = new Single3();这句话时发生了如下排序：

1. 为这个对象开辟一块空间
2. 将这个引用指向这块刚刚开辟的空间
3. 初始化这块空间

这个时候非常不巧：代码在执行完2的时候，恰巧有线程访问这个单例模式，获取单例，这个时候会发现，唉？这个引用不为null哦，有对应的对象（其实还没有赋值初始化呢！），那就返回这个引用，这时候就悲催了，这个引用在使用的时候，就会发生报错。所以必须加volatile关键词，防止指令重排序！

public class Single3 {
    private static volatile Single3 single = null;
    public Single3 getInstance(){

        if (single == null){
            synchronized(Single3.class){
                if (single == null){
                    single = new Single3();
                }
            }
        }
        return single;
    }
}

2.3使用私有的静态内部类来解决这个问题，实现懒加载。

因为只有使用的时候才发生类加载，所以也在使用的时候，发生类加载，又因为是静态字段，所以类加载的时候初始化字段，实现仅仅实例化一次单例，也很巧妙。

public class Single2 {
    private static class Instance {
        private static final Single2 single2 = new Single2();
    }
    private Single2(){}

    public Single2 getInstance() {
        return Instance.single2;
    }
}