Java单例模式

在网上看的单例模式的几种实现，自己手写了下例子，贴出来留着以后复习用

1.饿汉式

/**
 * @CopyRight: 版权所有
 * @Description: 饿汉式的特点：线程安全，调用效率高，但是不能延时加载
 * @Date: Created in 2019/8/26 11:54
 */
public class HungryManSingleton {

    /**
     * 单例模式需要满足的三个条件
     * 构造函数私有化；
     * 自行创建唯一实例，并向用户公布返回该实例的接口；
     * 定义一个唯一对象。
     */

    /**
     * 实例化这个类
     */
    private static final HungryManSingleton INSTANCE = new HungryManSingleton();


    /**
     * 私有构造方法
     */
    private HungryManSingleton() {

    }

    /**
     * 对外提供公开静态方法返回唯一实例
     *
     * @return 实例对象
     */
    public static HungryManSingleton getIntance() {
        return INSTANCE;
    }
}

2.懒汉式

/**
 * @CopyRight: 版权所有
 * @Description: 懒汉式的特点：线程安全，调用效率不高，但是能延时加载；
 * @Date: Created in 2019/8/26 12:18
 */
public class SluggardSingleton {

    /**
     * 类初始化时，不初始化这个对象（懒加载真正用的时候采取加载）
     */
    private static SluggardSingleton instance;

    /**
     * 私有构造函数
     */
    private SluggardSingleton() {

    }

    /**
     * 创建静态方法让外部可以获取实例
     * 方法同步调用效率低
     *
     * @return 实例
     */
    public static synchronized SluggardSingleton getInstance() {
        if (instance == null) {
            instance = new SluggardSingleton();
        }
        return instance;
    }


}

3.双重检查锁

/**
 * @CopyRight: 版权所有
 * @Description: Double CheckLock也就是双重锁判断机制（由于JVM底层模型原因，偶尔会出问题，不建议使用），是在懒汉式单例上发展而来
 * @Date: Created in 2019/8/26 12:29
 */
public class DoubleCheckLockSingleton {

    /**
     * volatile：作用其它线程可见，当instance改变其它线程可以立即看见，不用去等锁释放增加了效率
     * 类初始化时，不初始化这个对象（懒加载真正用的时候采取加载）
     */
    private static volatile DoubleCheckLockSingleton instance;


    /**
     * 私有构造函数
     */
    private DoubleCheckLockSingleton() {

    }

    /**
     * 静态方法
     * 双重锁判断机制
     *
     * @return .
     */
    public static DoubleCheckLockSingleton getInstance() {
        if (instance == null) {
            synchronized (DoubleCheckLockSingleton.class) {
                if (instance == null) {
                    instance = new DoubleCheckLockSingleton();
                }
            }
        }
        return instance;
    }


}

4.静态内部类

/**
 * @CopyRight: 版权所有
 * @Description: 静态内部类，静态内部类模式的特点：线程安全，调用效率高，可以延时加载；
 * @Date: Created in 2019/8/26 12:39
 */
public class StaticInnerClassSingleton {

    /**
     * 静态内部类
     */
    private static class InnerClass {
        private static final StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
    }

    /**
     * 私有构造函数
     */
    private StaticInnerClassSingleton() {

    }

    /**
     * 静态方法
     *
     * @return .
     */
    public static StaticInnerClassSingleton getInstance() {
        return InnerClass.INSTANCE;
    }
}

5.枚举类

/**
 * @CopyRight: 版权所有
 * @Description: 枚举类，枚举类特点：线程安全，调用效率高，不能延时加载，可以天然的防止反射和反序列化调用；
 * @Date: Created in 2019/8/26 13:30
 */
public class EnumSingleton {

    /**
     * 单例对象占用资源少，不需要延时加载时：枚举好于饿汉 ；
     * 单例对象占用资源多，需要延时加载时：静态内部类 好于 懒汉式。
     */

    /**
     * 枚举
     */
    private enum Singleton {
        INSTANCE;

        private EnumSingleton instance;

        public EnumSingleton getInstance() {
            return instance;
        }

        private Singleton() {
            instance = new EnumSingleton();
        }
    }


    /**
     * 私有构造函数
     */
    private EnumSingleton() {

    }

    /**
     * 静态方法
     *
     * @return .
     */
    public static EnumSingleton getInstance() {
        return Singleton.INSTANCE.getInstance();
    }

}