单例模式

1.1饿汉式

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
 * 单例模式-饿汉式
 */
public class SingleTon1 {
    private static SingleTon1 mInstance = new SingleTon1();
	
    private SingleTon1() {//私有构造方法
    }
	
    public static SingleTon1 getInstance() {//提供静态方法，获取对象实例
        return mInstance;
    }
}

1.2懒汉式

懒汉式-线程不安全

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
 * 单例模式-懒汉式(线程不安全)
 */
public class SingleTon2 {
    private static SingleTon2 mInstance;

    private SingleTon2() {}

    public static SingleTon2 getInstance() {
        if (mInstance == null) {
            mInstance = new SingleTon2();
        }
        return mInstance;
    }
}

1.3DCL单例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/**
 * 单例模式-DCL单例
 * 使用volatile + synchronized 保证线程安全
 */
public class SingleTon3 {
    private static volatile SingleTon3 mInstance;

    private SingleTon3() {}

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

1.4静态内部类单例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
 * 单例模式-静态内部类单例
 * 静态内部类的优点是：外部类加载时并不需要立即加载内部类，内部类不被加载则不去初始化INSTANCE，故而不占内存
 * 只有当getInstance()方法第一次被调用时，才会去初始化INSTANCE
 */
public class SingleTon4 {
    private SingleTon4() { }

    private static class Holder{
        private static volatile SingleTon4 mInstance = new SingleTon4();
    }

    public static SingleTon4 getInstance() {
        return Holder.mInstance;
    }
}

1.5容器类单例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
 * 单例模式-容器类单例
 */
public class SingleTon5 {
    private SingleTon5() { }
    private static Map<String,Object> map = new HashMap<>();

    public static void registerService(String key,Object value){
        if (!map.containsKey(key)){
            map.put(key,value);
        }
    }

    public static Object getService(String key){
        return map.get(key);
    }
}