单例模式写法详解

public class LazyUnSafeSingle {
    /** 优点：懒加载启动快，资源占用小，使用时才实例化，无锁。
     *  缺点：非线程安全。
     */
    private static LazyUnSafeSingle single = null;
    private LazyUnSafeSingle (){
    }
    public static  LazyUnSafeSingle getInstance(){
        if(single == null){
            single = new LazyUnSafeSingle();
        }
        return single;

    }

public class LazySafeSingle {
    /** 优点：懒加载启动快，资源占用小，使用时才实例化，加锁。
     *  缺点：synchronized 为独占排他锁，并发性能差。即使在创建成功以后，获取实例仍然是串行化操作。
     */
    private static LazySafeSingle single = null;
    private LazySafeSingle(){

    }
    public static  synchronized LazySafeSingle getInstance(){
        if (single == null){
            single = new LazySafeSingle();
        }
        return single;
    }
}

public class LazySafeDoubleCheckLockSingle {
    /** 优点：懒加载，线程安全。
     *  缺点：实例必须有 volatile 关键字修饰，其保证初始化完全,（这里体现的是有序性）。
     */
    private volatile static LazySafeDoubleCheckLockSingle single = null;
    private LazySafeDoubleCheckLockSingle(){
    }
    public static  LazySafeDoubleCheckLockSingle getInstance(){
        if(single == null){
            synchronized(LazySafeDoubleCheckLockSingle.class){
                if(single == null){
                    single = new LazySafeDoubleCheckLockSingle();
                }
            }
        }
        return single;
    }
}

public class UnLazySafeSingle {
    /** 优点：饿汉模式天生是线程安全的，使用时没有延迟。
     *  缺点：启动时即创建实例，启动慢，有可能造成资源浪费。
     */
    private static UnLazySafeSingle single = new UnLazySafeSingle();
    private UnLazySafeSingle(){
    };
    public static UnLazySafeSingle getInstance(){
        return single;
    }


}

public class HolderSingle {
    /**
     * 优点：将懒加载和线程安全完美结合的一种方式（无锁）
     * 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例，没有绑定关系，而且只有被调用到才会装载，从而实现了延迟加载
     */
    private HolderSingle() {}

    private static  class Holder{
        /**
         * 静态初始化器，由JVM来保证线程安全
         */
        private static  HolderSingle single = new HolderSingle();

    }
    public static HolderSingle  getInstance(){
        return Holder.single;
    }
}