设计模式——三种单例模式的实现

单例模式：在整个系统的生命周期中，有且只有一个实例。在某些场景下，处于多线程、资源方面的考虑，我们需要限制某个类只能创建一个实例，这是就要使用单例设计模式。
单例设计模式也是spring中应用最广泛的设计模式之一。spring的bean管理提供了一个全局访问的BeanFactory，通过BeanFactory提供一个默认的全局Bean的单例模式，不过没有从构造器级别控制单例，是因为Spring管理的是任意的Java对象。

1、饿汉式

/**
 * 单例模式：饿汉式
 * 在类加载时，就创建单例对象
 * 执行效率高，但是占空间，以空间换时间
 * 线程安全
 */
public class Hungry {

    private static final Hungry hungry = new Hungry();

    private Hungry(){}

    public static Hungry getInstance(){
        return  hungry;
    }
}

2、懒汉式

第一种：双重判断

/**
 * 单例模式：懒汉式  双重判断
 * 对象使用的时候，才去创建
 * 有线程安全的风险，需要加锁
 */
public class Lazy1 {
    private Lazy1(){}

    private static Lazy1 instance = null;

    public static Lazy1 getInstance(){
        if(instance == null){
            synchronized (Lazy1.class){
                if(instance == null){
                    instance = new Lazy1();
                }
            }
        }
        return instance;
    }
}

第二种：静态内部类

/**
 *单例模式：懒汉式  静态内部类
 * 静态内部类在使用时，才加载
 * 此种模式，既是懒加载，又没有加锁影响性能
 */
public class Lazy2 {
    private Lazy2(){}

    public static final Lazy2 getInstance(){
        return LazyLoad.instance;
    }

    private static class LazyLoad{
        private static final Lazy2 instance = new Lazy2();
    }
}

3、注册式

/**
 * 懒汉式的变种
 * spring IOC容器就是使用的这种注册式的单例模式
 */
public class BeanFactory {

    public static Map<String,Object> ioc = new ConcurrentHashMap<String,Object>();

    public static Object getBean(String className){
        if(!ioc.containsKey(className)){
            try {
                Object instance = Class.forName(className).newInstance();
                ioc.put(className, instance);
                return instance;
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return ioc.get(className);
    }
}