再学Singleton模式

• 最简单的实现方式

public class Singleton {
    private static final Singleton SINGLETON = new Singleton();//自动构建

    public static Singleton getInstance(){
        return SINGLETON;
    }
    private Singleton(){}//封闭对外实现
}

• 改进版本

public class Singleton {
    private static class SingletTool{
        private static final Singleton SINGLETON = new Singleton();//滞后加载
    }
    public static Singleton getInstance(){
        return SingletTool.SINGLETON;
    }
    private Singleton(){}
}

• 通过枚举实现

public enum Singleton {
    SINGLETON;

    private Singleton(){

    }
}

以上两种形式都是通过static变量初始化原理,来实现单例
改进版的优点在于使得单粒的初始化滞后于Singleton类的使用
优点在于不必担忧多线程情形下的假Singleton
缺点在于对外缺乏灵活的接口
枚举版本的单例实现更加简单,和未改进版相差不大

---

• 多线程下Singleton

public class Singleton {
    private static volatile Singleton singleton;

    private static Singleton getInstance(String config){
        Singleton temp = singleton;//使用temp刷新singleton值
        if(temp == null){
            synchronized (Singleton.class) {
                temp = singleton;
                if(temp == null){
                    temp = new Singleton(config);
                    singleton = temp; //通过volatile操作确定有序性
                }
            }
        }
        return temp;//返回临时变量,节省时间
    }

    private Singleton(String config){}
}

对外提供了灵活的接口
多线程情形下安全

• 单例MAP形式的构造

public class Singleton {
    public static final Map<String, Singleton> SINGLE_MAP = new ConcurrentHashMap<String, Singleton>();//map 记录

    public static Singleton getInstance(String config){
        if(SINGLE_MAP.containsKey(config)){
            return SINGLE_MAP.get(config);
        }else{
            synchronized (Singleton.class) { //加锁
                Singleton singleton = null;
                if(!SINGLE_MAP.containsKey(config)){
                    singleton = new Singleton(config);
                    SINGLE_MAP.put(config, singleton);
                }
                return singleton;
            }
        }
    }
    private Singleton(String config){}
}

适用场景,在于map中value值的个数有限个
map的value对java对内存清理具有阻碍性