单例模式的四种写法

/**
 *  单例模式的四种写法

 * 
 *  例1: 在多个功能模块里都需要写log。为了把log集中处理，便于分析与运维，log对象可以是单例的。
 *  例2: 有一个配置文件，很多功能模块都会需要其中的一部分数据，模块1需要A部分，模块2需要B部分。配置文件对象可以是单例的。
 *  例3: 有一个通用的计算模块，它总是根据传进来的参数算出结果。这个通用模块会被很多类调用。那么它也可以是单例的。
 *  例4: 在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。
 */

/**
 * 单例模式--枚举
 * 枚举的三个特性：自由序列化，线程安全，保证单例
 * enum有且仅有private的构造器，防止外部的额外构造，这恰好和单例模式吻合，也为保证单例性做了一个铺垫
 */
public enum EnumSingleton {
    /**轮播图*/
    BANNER(1,"banner"),

    /**导航*/
    NAVIGATION(2,"navigation"),

    /**标题*/
    TITLE(3,"title");

    private Integer code;

    private String  name;

    public static EnumSingleton getEnumsByCode(Integer code){
        if(null != code ){
            for(EnumSingleton enums: EnumSingleton.values()){
                if(code.equals(enums.getCode())){
                    return enums;
                }
            }
        }
        return null;
    }

    private EnumSingleton(Integer code, String name) {
        this.code = code;
        this.name = name;
    }
    /**
     * @return code
     */

    public Integer getCode() {
        return code;
    }
    /**
     * @param code
     */
    public void setCode(Integer code) {
        this.code = code;
    }
    /**
     * @return name
     */

    public String getName() {
        return name;
    }
    /**
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }
}

/**
 *  单例模式--双重检锁
 *  线程安全   效率高    内存占用低  多线程操作原子性
 */
public class DoubleCheckLockSingleton {

    /** 定义一个静态私有变量 使用volatile关键字修饰 当对象变更时会强制写入内存中**/
    private static volatile DoubleCheckLockSingleton  doubleCheckLockSingle;

    /** 定义一个私有构造函数 **/
    private DoubleCheckLockSingleton(){

    }

    /** 定义一个共有的静态方法,返回该类型的实例**/
    public static DoubleCheckLockSingleton getInstance(){
        // 对象实例化时与否判断
        if(null==doubleCheckLockSingle){
            synchronized (DoubleCheckLockSingleton.class){
                //未初始化,则初始instance
                if (null==doubleCheckLockSingle){
                    doubleCheckLockSingle=new DoubleCheckLockSingleton();
                }
            }
        }
        return doubleCheckLockSingle;
    }
}

/**
 * 单例模式--饿汉式
 * 在单例类被加载时候，就实例化一个对象交给自己的引用
 */
public class HungrySingleton {

    private static HungrySingleton hungrySingleton=new HungrySingleton();

    private HungrySingleton(){

    }

    public static HungrySingleton getInstance(){

        return hungrySingleton;
    }
}

/**
 * 单例模式--懒汉式
 * 在调用取得实例方法的时候才会实例化对象
 */
public class LazySingleton {

    private static LazySingleton lazySingleton;

    private LazySingleton(){

    }

    public static synchronized LazySingleton getInstance(){
        if(null==lazySingleton){
            lazySingleton=new LazySingleton();
        }
        return lazySingleton;
    }
}

单例模式的四种写法

猜你喜欢