女朋友惊掉下巴问我：单例模式竟有七种写法？

/** * 饿汉式：通过classloader机制避免了多线程的同步问题，在类装载的时候完成实例化 * 优点：写法简单，类装载的时候完成实例化，避免了线程同步的问题 * 缺点：未达到lazy loading的效果，如果始终未用到则可能造成资源浪费 * 适用场景： */public class HungrySingleton {
    //1、构造器私有化    private HungrySingleton(){}    //2、类的内部创建对象的实例    private final static HungrySingleton dayu = new HungrySingleton();    //3、将类的内部实例提供一个静态方法返回出去    private static HungrySingleton getInstance(){        return dayu;    }
}

/** * 懒汉式 * 缺点：线程不安全，工作中一般不用 */public class NotSafeLazySingleton {    //构造器私有化    private NotSafeLazySingleton(){}    //暂时不加载实例    private static NotSafeLazySingleton dayu;
    /**     * 存在线程安全问题     * 线程A到括号dayu == null判断完之后，进入括号内部，     * 此时线程B获得执行权，判断==null也是true，所以也进入     * 此时两个线程便出现了两个dayu对象     * @return     */    public static NotSafeLazySingleton getInstance(){        if(dayu == null){            dayu = new NotSafeLazySingleton();        }        return dayu;    }}

/** * 懒汉式安全写法 * 缺点：Synchronized关键字导致方法效率低 效率极低 * 优点：线程安全 * 适用场景：实际开发 不推荐使用 */public class SafeLazySingleton {    //构造器私有化    private SafeLazySingleton(){}    //暂时不加载实例    private static SafeLazySingleton dayu;
    /**     * synchronized导致所有通过该方法获取该对象的时候都要排队     */    public static synchronized SafeLazySingleton getInstance(){        if(dayu == null){            dayu = new SafeLazySingleton();        }        return dayu;    }}

/** *  本意上是对SafeLazySingelton的改进 因为前面的对整个方法进行加锁的效率实在是太低了 *  但是这种还是不能起到线程同步的作用 和NotSafeLazySingelton类似 只要线程进入了== null的里面 *  此时另一个线程获得CPU分配的时间片 则会出现多个对象 */public class NotSafeLaySingleton2 {
    //构造器私有化    private NotSafeLaySingleton2(){}    //暂时不加载实例    private static NotSafeLaySingleton2 dayu;
    /**     * @return     */    public static NotSafeLaySingleton2 getInstance(){        if(dayu == null){            synchronized (NotSafeLaySingleton2.class){                dayu = new NotSafeLaySingleton2();            }        }        return dayu;    }}

/** * 双重检测单例：稳得一批 * 优点：线程安全 延迟加载 效率相对来说也不错 *使用场景：实际开发中 用的比较多 */public class DoubleCheckSingleton {
    private static volatile DoubleCheckSingleton dayu;    private DoubleCheckSingleton(){}    /**     * 解决线程安全的问题同时 也解决懒加载问题     * @return     */    public static DoubleCheckSingleton getInstance(){        if(dayu == null){            synchronized (DoubleCheckSingleton.class){                if(dayu == null){                    dayu = new DoubleCheckSingleton();                }            }        }        return dayu;    }}

/** * 静态内部类加载单例 * 优点：类装载机制保证线程安全 懒加载 只有调用getInstance才会加载内部类 * 适用场景： */public class StaticInnerClassSingleton {    private StaticInnerClassSingleton(){}
    /**     * 1、外部类被装载时  内部不会立即被装载     * 2、调用getInstance方法时会装载 只会装载一次 且不存在线程安全     */    private static class SingletonInstance{        private static final StaticInnerClassSingleton dayu = new StaticInnerClassSingleton();    }    //返回静态内部类中的对象    public static StaticInnerClassSingleton getInstance(){        return SingletonInstance.dayu;    }}

/** * 枚举实现单例 * 优点：简洁 无线程安全问题 还可以防止反序列化重新创建新的对象 * Effective Java作者Josh Bloch提倡的方法 */public class EnumSingleton {
    public static void main(String[] args) {        //instance和instance2是同一个对象        Singleton instance = Singleton.INSTANCE;        Singleton instance2 = Singleton.INSTANCE;    }
    enum Singleton{        INSTANCE;    }}