设计模式之单例模式

单例模式（Singleton Pattern）是指确保一个类在任何情况下都绝对只有一个实例，并 提供一个全局访问点。单例模式是创建型模式

饿汉式单例

是在类加载的时候就立即初始化，并且创建单例对象。绝对线程安全，在线程还没出现以前就是实例化了，不可能存在访问安全问题。

示例代码

//饿汉式的单例模式
public class HugrySingleton {

    //一个私有的构造方法
    private HugrySingleton(){};
    //立刻初始化
    private static final HugrySingleton hugrySingleton = new HugrySingleton();

    //也可以利用静态代码块
//    private static final HugrySingleton hungrySingleton;
//    static { hungrySingleton = new HugrySingleton(); }
    //一个全局的访问点
    public static HugrySingleton getInstance(){
        return hugrySingleton;
    }
}

优点：没有加任何的锁、执行效率比较高，在用户体验上来说，比懒汉式更好。

缺点：类加载的时候就初始化，不管用与不用都占着空间，浪费了内存

 

懒汉式单例

特点只有在外部调用时才会初始化

双重锁检查懒汉式

public class LazyDoubleCheckSingleton {

    private LazyDoubleCheckSingleton(){};

    public LazyDoubleCheckSingleton lazyDoubleCheckSingleton = null;


    public LazyDoubleCheckSingleton getInstance() {

        if(lazyDoubleCheckSingleton == null){
            // 加锁检查防止多线程创建不同对象
            synchronized (this){
                // 只有空对象检查通过才去创建
                if(lazyDoubleCheckSingleton == null){
                    new LazyDoubleCheckSingleton();
                }
            }
        }
        return lazyDoubleCheckSingleton;
    }
}

静态内部类懒汉式

//静态内部类的初始化单利
public class LazyInnerSingleton {
    private LazyInnerSingleton(){};

    //static 防止继承重写，用到的时候先初始化静态内部类
    public static final LazyInnerSingleton getInstance(){
        return LazyHolder.LAZYINNERSINGLETON;
    }


    //默认不加载只有在用到这个类的时候才加载
    public static class LazyHolder{

        private static  final LazyInnerSingleton LAZYINNERSINGLETON = new LazyInnerSingleton();
    }
}

推荐枚举实现单例模式

天然支持单例

public enum SingletonEnum {
    INSTANCE();

}

class EnumTest{
    public static void main(String[] args) {
        SingletonEnum instance = SingletonEnum.INSTANCE;
        SingletonEnum instance2 = SingletonEnum.INSTANCE;

        System.out.println(instance.hashCode() == instance2.hashCode());
    }

}