Java单例模式与延迟加载分析 Singleton & Lazy Initialized

/*
 * 单态类:使用内部类方式 根据Java规范，JVM将保证在使用到内部类时才去初始化其成员变量，并保证线程安全（推荐）
 */
public class Singleton{
    private static class InnerClass{
        private static Singleton singleton = new Singleton();
    }
    public static Singleton getInstance(){
        return InnerClass.singleton;
    }
}

/*
 * 单态类：非线程安全，仅在单线程中能够保证唯一实例
 */
class SingletonSingleThread{
    private static SingletonSingleThread instance;
    private SingletonSingleThread(){}
    public static SingletonSingleThread getInstance(){
        if(instance == null)
            instance = new SingletonSingleThread();
        return instance;
    }
}

/*
 * 单态类一：线程安全。但非延迟初始化，可能造成资源浪费
 */
class SingletonOne{
    private static SingletonOne instance = new SingletonOne();
    private SingletonOne(){}
    public static SingletonOne getInstance(){
        return instance;
    }
}

/*
 * 单态类二：普通的单态类设计，但可能效率相对低
 */
class SingletonTwo{
    private static SingletonTwo instance;
    private SingletonTwo(){}
    public static synchronized SingletonTwo getInstance(){
        if(instance == null)
            instance = new SingletonTwo();
        return instance;
    }   
}
/*
 * 单态类三：允许延迟初始化单态类，需要JSR133(但仍然可能存在问题)
 */
class SingletonThree{
    private static volatile SingletonThree instance;
    private SingletonThree(){}
    public static SingletonThree getInstance(){
        if(instance == null){
            synchronized(SingletonThree.class){
                if(instance == null)
                    instance = new SingletonThree();
            }
        }
        return instance;
    }
}