重拾单例模式

非常不情愿地表情重拾单例模式T_T

1、传说中的饿汉模式

   public class Singleton0 {
    public static final Singleton0 sInstance = new Singleton0();
    private Singleton0(){
    }
    public static Singleton0 getInstance(){
        return sInstance;
    }
}

特点：在加载Singleton0 类时便会初始化实例，频繁使用的对象可以用这种方式。但是会影响启动速度。
2、传说中的懒汉模式

public class Singleton1 {
    private static Singleton1 instance = null;
    public static synchronized Singleton1 getInstance(){
        if( instance == null){
            instance = new Singleton1();
        }
        return instance;
    }
}

特点：只有在使用时才会初始化实例，但是同步锁比较消耗性能，一般很少用。

3、懒汉模式优化--DCL 双检锁模式

public class Singleton2 {
    private static Singleton2 sInstance = null;
    private Singleton2(){
    }
    public static Singleton2 getInstance(){
        if( sInstance == null){
            synchronized (Singleton2.class) {
                if( sInstance == null){
                    sInstance =  new Singleton2();
                }
            }
        }
        return sInstance;
    }
}

特点：兼备懒汉模式的优点，在使用时才加载，并且优化了锁，效率高。第一个判空是为了避免不必要的同步，第二个判空是为了在Null情况下才创建实例。
但是，网络里有个说法--由于new并不是一个原子操作：
(1)给Singleton2 的实例分配内存 （2）调用Singleton2 ()构造函数，并初始化成员
(3)将sIntance指向目标内存，sInstance就不是null了
但是由于指令重排，可能会导致2和3是乱序执行的，就是说可能导致某个线程取到的对象不为空，但是并没有实际地构造出来，导致出错。
我认为这个说法不太对，因为synchronized 关键字已经是带了禁止指令重排。。我觉得导致出错还是因为可见性的问题，但是仔细想，synchronized不是可以保重可见性的问题嘛。不太确认他们说会出问题,无法分辨，哪位大佬知道的，分享下T_T
解决办法是sInstance 加上volatile,但是volatile会稍微影响到性能。一般来说不加volatile基本够用，如果不是在要求非常苛刻的情况或者jdk6以下版本使用。
4、静态内部类的单例模式

public class Singleton3 {
    private Singleton3(){   
    }
    public static Singleton3 getInstance(){
        return  SingletonHolder.sInstance;
    }
    private static  class SingletonHolder{
        private static final Singleton3 sInstance = new Singleton3();
    }
}

特点：保持了懒汉模式的优点，类加载时不会初始化对象，只有在使用getInstance时才会初始化。getInstance导致虚拟机加载SingletonHolder类，类的静态变量初始化，正是在这个时候进行的。这种方式既保证了线程安全，又保证了对象唯一性，值得推荐。