1、单例模式的实现方式

饿汉式单例

缺陷：静态变量在类加载时就被放入方法区的常量池，在真正需要使用单例对象之前，浪费方法区内存

public class Single_Early {

    /**
     * 构造方法私有化，防止外界调用，只能通过单例方式调用
     */
    private Single_Early(){}

    /**
     * 对象只初始化一次，作为成员变量值
     */
    private static Single_Early instance = new Single_Early();

    /**
     * 每次获取对象，都只获取实例化好的静态对象
     */
    public static Single_Early getInstance() {
        return instance;
    }

}

懒汉式单例

线程不安全的懒汉式单例

public class SingleObject_2_Lazy {

    private SingleObject_2_Lazy(){}

    private static SingleObject_2_Lazy instance;

    /**
     * 对象为空时，初始化好一个对象并存到内存里，供后续使用
     */
    public static SingleObject_2_Lazy getInstance(){
        if (instance == null) {
            instance = new SingleObject_2_Lazy();
        }
        return instance;
    }

}

线程安全的懒汉式单例

public class SingleObject_3_Lazy_Safe {

    private SingleObject_3_Lazy_Safe(){}

    private static SingleObject_3_Lazy_Safe instance;

    /**
     * 通过synchronized控制，同一时刻只能有一个线程调用这个方法，缺点是效率比较低，可能造成阻塞
     */
    public static synchronized SingleObject_3_Lazy_Safe getInstance(){
        if (instance == null) {
            instance = new SingleObject_3_Lazy_Safe();
        }
        return instance;
    }
}

双重检查锁单例

public class SingleObject_4_DoubleCheck {

    private static SingleObject_4_DoubleCheck instance;

    private SingleObject_4_DoubleCheck(){}

    /**
     * 没有锁住getInstance方法，多个线程可以同时调用， 而instance为null时锁住类
     * 这样一来只有在第一次初始化的时候会锁一次
     * 之后都不会再锁，即保证了线程安全，又提高了效率
     */
    public static SingleObject_4_DoubleCheck getInstance(){
        if (instance == null) {
            synchronized (SingleObject_4_DoubleCheck.class){
                if (instance == null) {
                    instance = new SingleObject_4_DoubleCheck();
                }
            }
        }

        return instance;
    }
}

内部静态类/登记式单例

public class SingleObject_5_Holder {

    private SingleObject_5_Holder(){}

    /**
     * 静态内部类里面的成员变量和成员方法（都是静态的），只有被调用的时候才会被加载,类似双重检测
     */
    private static class Holder {
        private static SingleObject_5_Holder INSTANCE = new SingleObject_5_Holder();
    }

    public SingleObject_5_Holder getInstance(){
        return Holder.INSTANCE;
    }
}

枚举方式实现单例

public enum SingleObject_6_Enum {
    INSTANCE;
    /**
	 * 枚举方式,不仅能避免多线程同步问题
	 * 而且自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化
 	 */
    public void test(){
        System.out.println("测试方法，枚举对象已经被初始化");
    }
}