单例模式

一、使用单例模式的原因和方法

原因：多个线程要操作同一对象，要保证对象的唯一性
方法：实例化过程中只实例化一次

二、单例模式三个主要特点：

构造方法私有化；
实例化的变量引用私有化；[ 有一个实例化的过程（只有一次），产生实例化对象 new ]
获取实例的方法共有。[ 提供返回实例对象的方法 getInstace() ]

三、评判单例模式的标准

线程的安全性、
性能、
懒加载（lazy ）

四、常用的单例模式

1、单例的饿汉模式

public class Singleton {
    /*
     * 利用静态变量来记录Singleton的唯一实例
     * 直接初始化静态变量，这样就可以确保线程安全了
     */
    private static Singleton uniqueInstance = new Singleton();

    /*
     * 构造器私有化，只有Singleton类内才可以调用构造器
     */
    private Singleton() {

    }

    public static Singleton getInstance() {
        return uniqueInstance;
    }

}复制代码

线程安全性：在加载的时候已经被实例化，所以只有这一次，线程安全的。JVM ClassLoader
懒加载：没有延迟加载，好长时间不使用，影响性能
性能比较好

2、懒汉式

public class HoonSingleton {
    private static HoonSingleton instance=null;
    private HoonSingleton(){
    }
    public static HoonSingleton getInstance(){
        if(null==instance)
            instance=new HoonSingleton();
        return instance;
    }
}复制代码

线程安全性：不能保证实例对象的唯一性（不安全）
懒加载：延迟加载

3、懒汉的双重加锁机制（DCL ：Double-Check-Locking）

package cn.njauit;

public class Singleton {
    /*
     * 利用静态变量来记录Singleton的唯一实例
     * volatile 关键字确保：当uniqueInstance变量被初始化成Singleton实例时，
     * 多个线程正确地处理uniqueInstance变量(保证了有序性，解决了编译重排重排和运行重排问题)
     *
     */
    private volatile static Singleton uniqueInstance;

    /*
     * 构造器私有化，只有Singleton类内才可以调用构造器
     */
    private Singleton() {

    }

    /*
     *
     * 检查实例，如果不存在，就进入同步区域
     */
    public static Singleton getInstance() {
        if (uniqueInstance == null) {
            synchronized (Singleton.class) {    //进入同步区域
                if (uniqueInstance == null) {     //在检查一次，如果为null，则创建
                    uniqueInstance = new Singleton();
                }
            }
        }

        return uniqueInstance;
    }

}复制代码

性能比较好
懒加载：是
线程的安全性：安全

4、静态内部类(Holder 型)

静态内部类延迟加载

package cn.njauit;

public class Singleton {

    //声明类的时候，成员变量中不声明实例变量，而放到内部静态类中
    private static class LazyHolder {
       private static final Singleton INSTANCE = new Singleton();
    }
    private Singleton (){}
    //懒加载
    public static final Singleton getInstance() {
       return LazyHolder.INSTANCE;
    }
}复制代码

5.1、枚举单例示例

public enum  EnumSingleton {
    INSTANCE;//INSTANCE 就是 EnumSingleton 的常量,只能初始化一次，天生为单例
    public EnumSingleton getInstance(){
        return INSTANCE;
    }
}复制代码

5.2、完整的枚举单例

package cn.njauit;

public class EnumSingletonDemo {
    private EnumSingletonDemo() {
    }

    //匿名内部静态枚举类具有延迟加载性质
    private enum EnumHolder {
        /**
         * 创建一个枚举对象，该对象天生为单例
         */
        INSTANCE;
        private EnumSingletonDemo instance;

        EnumHolder() {
            instance = new EnumSingletonDemo();
        }
    }
    //懒加载 //对外暴露一个获取Instance的静态方法
    public static EnumSingletonDemo getInstance() {
        return EnumHolder.INSTANCE.instance;
    }

} 复制代码