/**
 * @Auther: Arsenal
 * @Date: 2020-03-06 21:50
 * @Description: 单例模式
 */
public class Singleton {
    public static void main(String[] args) {
        EagerSingleton instance1 = EagerSingleton.getInstance();
        EagerSingleton instance2 = EagerSingleton.getInstance();
        System.out.println("=====饿汉式=====");
        System.out.println(instance1 == instance2);
        System.out.println(instance1);
        System.out.println(instance2);
        System.out.println("=====Double-Check懒汉式=====");
        LazyDoubleCheckSingleton instance3 = LazyDoubleCheckSingleton.getInstance();
        LazyDoubleCheckSingleton instance4 = LazyDoubleCheckSingleton.getInstance();
        System.out.println(instance3 == instance4);
        System.out.println(instance3);
        System.out.println(instance4);
        System.out.println("=====静态内部类懒汉式=====");
        LazyStaticInnerClassSingleton instance5 = LazyStaticInnerClassSingleton.getInstance();
        LazyStaticInnerClassSingleton instance6 = LazyStaticInnerClassSingleton.getInstance();
        System.out.println(instance5 == instance6);
        System.out.println(instance5);
        System.out.println(instance6);
        System.out.println("=====枚举懒汉式=====");
        LazyEnumSingleton instance7 = LazyEnumSingleton.INSTANCE;
        LazyEnumSingleton instance8 = LazyEnumSingleton.INSTANCE;
        System.out.println(instance7 == instance8);
        System.out.println(instance7);
        System.out.println(instance8);
    }
}


/**
 * 饿汉式（静态常量）应用实例
 * 步骤如下：
 * 1) 构造器私有化 (防止 new )
 * 2) 类的内部创建对象
 * 3) 向外暴露一个静态的公共方法。 getInstance
 * 4) 代码实现
 * <p>
 * 优缺点说明：
 * 1) 优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同
 * 步问题。
 * 2) 缺点：在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始
 * 至终从未使用过这个实例，则会造成内存的浪费
 * 3) 这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载
 * 时就实例化，在单例模式中大多数都是调用getInstance方法， 但是导致类装载
 * 的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类
 * 装载，这时候初始化instance就没有达到lazy loading的效果
 * 4) 结论：这种单例模式 可用， 可能造成内存浪费
 */
class EagerSingleton {
    private final static EagerSingleton eagerSingleton = new EagerSingleton();

    private EagerSingleton() {
    }

    public static EagerSingleton getInstance() {
        return eagerSingleton;
    }
}

/**
 * 优缺点说明：
 * 1) Double-Check概念是多线程开发中常使用到的，如代码中所示，我们进行了两
 * 次if (singleton == null)检查，这样就可以保证线程安全了。
 * 2) 这样，实例化代码只用执行一次，后面再次访问时，判断if (singleton == null)，
 * 直接return实例化对象，也避免的反复进行方法同步.
 * 3) 线程安全；延迟加载；效率较高
 * 4) 结论：在实际开发中，推荐使用这种单例设计模式
 */
class LazyDoubleCheckSingleton {
    private LazyDoubleCheckSingleton() {
    }

    private static volatile LazyDoubleCheckSingleton lazySingleton;

    public static LazyDoubleCheckSingleton getInstance() {
        //双重检查
        if (lazySingleton == null) { //Double-Check
            synchronized (LazyDoubleCheckSingleton.class) {
                if (lazySingleton == null) {
                    lazySingleton = new LazyDoubleCheckSingleton();
                }
            }
        }
        return lazySingleton;
    }
}

/**
 * 优缺点说明：
 * 1) 这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
 * 2) 静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化
 * 时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的
 * 实例化。
 * 3) 类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们
 * 保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
 * 4) 优点：避免了 线程不安全，利用静态内部类特点实现延迟加载，效率高
 * 5) 结论：推荐使用.
 */
class LazyStaticInnerClassSingleton {
    private LazyStaticInnerClassSingleton() {
    }

    private static class SingletonInstance {
        private static final LazyStaticInnerClassSingleton INSTANCE = new LazyStaticInnerClassSingleton();
    }

    public static LazyStaticInnerClassSingleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}


/**
 * 优缺点说明：
 * 1) 这借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而
 * 且还能防止反序列化重新创建新的对象。
 * 2) 这种方式是Effective Java作者Josh Bloch 提倡的方式
 * 3) 结论：推荐使用
 */
enum LazyEnumSingleton {
    INSTANCE;

    public void method() {
    }
}