/**

 * 饿汉式：开始就创建了对象，饥不择食

 */

class SingletonHungry {

    private static SingletonHungry singletonHungry = new SingletonHungry();

    private SingletonHungry() {

    }

    /**

     * 不存在线程安全的问题

     */

    public static SingletonHungry getInstance() {

         return singletonHungry;

    }

}

/**

 * 懒汉式：需要用才创建

 */

class SingletonLazy {

    private static SingletonLazy singletonLazy = null;

    private SingletonLazy() {

    }

    /**

     * 存在线程安全问题

     */

    public static SingletonLazy getInstance() {

//  public static synchronized SingletonLazy getInstance() {

         if(null == singletonLazy) {

             singletonLazy = new SingletonLazy();

         }

         return singletonLazy;

    }

}

/**

 * 推荐用：静态内部类，解决线程安全问题

 * 原理：

 *   外部类加载时，并不需要立即加载内部类，内部类不被加载则不去初始化，所以不占内存，

 *   只有当getInstance()被调用时，JVM才会加载Inside类。

 * JVM在多线程环境下初始化一个类，那么只有有一个线程去执行这个类的方法，

 * 其他线程会阻塞，即同一个加载器下，一个类型只会被初始化一次，这种阻塞往往是很隐蔽的。

 * 所以可以看到Inside在创建过程是线程安全的，所以说静态内部类形式的单例可保证线程安全，也保证了单例的唯一性，同时也延迟了单例的实例化。

 */

class SingletonInside {

    public static class Inside {

         private static final SingletonInside SINGLETON_INSIDE = new SingletonInside();

    }

    private SingletonInside() {

    }

    public static SingletonInside getInstance() {

         return Inside.SINGLETON_INSIDE;

    }

}

/**

 * 双检查机制

 */

class SingletonDoubleCheck {

    private static SingletonDoubleCheck singletonDoubleCheck = null;

    public static SingletonDoubleCheck getInstance() {

         if(null == singletonDoubleCheck) {

             synchronized (SingletonDoubleCheck.class) {

                  singletonDoubleCheck = new SingletonDoubleCheck();

             }

         }

         return singletonDoubleCheck;

    }

}