1, 单例模式定义

确保某一个类只有一个实例,并且自行实例并且向整个系统提供这个实例.

2, 单例模式的实现方式.

2.1 饿汉式

public class CEO{
    // 创建静态对象.
    private static final CEO mCeo = new CEO();
    // 私有化构造方法.
    private CEO(){}
    // 共有静态方法,对外暴露获取单例对象接口 .
    public static CEO getCeo(){
        return mCeo;
    }
}
// 防止反序列化过程中重新创建对象.
private Object readResolve() throws ObjectStreamException{
    return mInstance;
}

2.2 懒汉式

// 懒汉式
public class Singleton_1{
    private static Singleton_1 mInstance;
    public static synchronized Singleton_1 getInstance(){
        if(mInstance == null){
            mInstance = new Singleton_1();
        }
        return mInstance;
    }
}
// 防止反序列化过程中重新创建对象.
private Object readResolve() throws ObjectStreamException{
    return mInstance;
}

优点 : 使用时才会被实例化,在一定程度上节约了资源.

缺点 : 第一次加载时需要及时进行实例化,反应稍慢. 最大的问题是,每次调用都需要进行
同步造成不必要的同步开销.这种模式一般不建议使用.

2.3 Double Check Lock (DCL)单例模式

// Double Check Lock (DCL)实现单例模式.
public class Singleton {
    private static Singleton mInstance = null;
    private Singleton(){}
    public static Singleton getInstance(){
        if (mInstance == null){
            // 添加同步锁.
            synchronized(Singleton.class){
                mInstance = new Singleton();
            }
        }
        return mInstance;
    }
}
// 防止反序列化过程中重新创建对象.
private Object readResolve() throws ObjectStreamException{
    return mInstance;
}

优点 : 资源利用率高,效率高.
确定 : 第一次加载时反应慢.

2.4 内部静态类单例模式(推荐使用).

// 内部静态了单例模式.
public class Singleton {
    private Singleton(){}
    public static Singleton getInstance(){
        return SingletonHolder.mInstance;
    }
    // 静态内部类
    private static class SingletonHolder{
        // 第一加载Singleton类时并不会初始化mInstance,
        // 只有第一次调用getInstance 时才会导致mIntance 被初始化.
        private static final Singleton mInstance = new Singleton();
    }
}
// 防止反序列化过程中重新创建对象.
private Object readResolve() throws ObjectStreamException{
    return mInstance;
}

2.5 枚举单例模式.

// 枚举单例模式
public enum SingletonEnum{
    INSTANCE;
    public void doSomething(){
        System.out.printlen("do sth");
    }
}

可以避免反序列化时重新创建对象.

2.6 使用容器实现单例模式.

// 容器实现单例模式
public class SingletonManager {
    private static Map<String , Object> objMap = new HashMap<String , Object>();
    
    private SingletonManager(){}
    
    public static void registerService(String key , Object instance){
        if (!objMap.containsKey(key)){
            objMap.put(key,instance);
        }
    }
    
    public static Object getService(String key){
        return objMap.get(key);
    }
}