《Head First 设计模式》（五）：单例模式

1. 定义

单例模式：确保一个类只有一个实例，并提供一个全局访问点

要素：

1. 单例类只能有一个实例
2. 单例类必须自行创建自己的实例
3. 单例类必须自行向整个系统提供这个实例

单例模式的简单实现：

package com.jbp.designpattern.singleton;

/**
 * @ClassName: Singleton
 * @description: 单例
 * @author: JiangBeiPing
 * @create: 2021-07-20 11:15
 * @Version: 1.0
 **/
public class Singleton {

    // 用一个静态变量来记录Singleton类的唯一实例
    private static Singleton uniqueInstance;

    // 构造器私有，只有Singleton类内部才能调用
    private Singleton() {
    }

    // 实例化对象并返回
    public static Singleton getInstance(){
        if (uniqueInstance == null){
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }
}

2. 常见实现方式

2.1 懒汉模式（线程不安全）

package com.jbp.designpattern.singleton;

/**
 * @ClassName: Singleton
 * @description: 单例
 * @author: JiangBeiPing
 * @create: 2021-07-20 11:15
 * @Version: 1.0
 **/
public class Singleton {

    // 用一个静态变量来记录Singleton类的唯一实例
    private static Singleton uniqueInstance;

    // 构造器私有，只有Singleton类内部才能调用
    private Singleton() {
    }

    // 实例化对象并返回
    public static Singleton getInstance(){
        if (uniqueInstance == null){
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }
}

2.2 饿汉模式

package com.jbp.designpattern.singleton;

/**
 * @ClassName: SingletonHungry
 * @description: 饿汉模式
 * @author: JiangBeiPing
 * @create: 2021-07-20 11:44
 * @Version: 1.0
 **/
public class SingletonHungry {

    private static SingletonHungry uniqueInstance = new SingletonHungry();

    private SingletonHungry() {
    }

    public static SingletonHungry getInstance(){
        return uniqueInstance;
    }
}

2.3 懒汉模式（线程安全）

package com.jbp.designpattern.singleton;

public class Singleton {

    // 用一个静态变量来记录Singleton类的唯一实例
    private static Singleton uniqueInstance;

    // 构造器私有，只有Singleton类内部才能调用
    private Singleton() {
    }

    // 实例化对象并返回
    public static synchronized Singleton getInstance(){
        if (uniqueInstance == null){
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }
}

2.4 双重检查模式

package com.jbp.designpattern.singleton;

/**
 * @ClassName: Singleton
 * @description: 单例
 * @author: JiangBeiPing
 * @create: 2021-07-20 11:15
 * @Version: 1.0
 **/
public class Singleton {

    // 用一个静态变量来记录Singleton类的唯一实例
    private volatile static Singleton uniqueInstance;

    // 构造器私有，只有Singleton类内部才能调用
    private Singleton() {
    }

    // 实例化对象并返回
    public static Singleton getInstance(){
        if (uniqueInstance == null){
            synchronized (Singleton.class){
                if (uniqueInstance == null){
                    uniqueInstance = new Singleton();
                }
            }
        }
        return uniqueInstance;
    }
}

2.5 静态内部类

package com.jbp.designpattern.singleton;

// 第一次加载SingletonStatic类时并不会初始化instance，只有第一次调用getInstance方法时虚拟机加载SingletonHolder 并初始化instance 
public class SingletonStatic {

    private SingletonStatic() {
    }

    public static SingletonStatic getInstance(){
        return SingletonHolder.instance;
    }

    private static class SingletonHolder{
        private static final SingletonStatic instance = new SingletonStatic();
    }

}

2.6 枚举

package com.jbp.designpattern.singleton;

/**
 * @ClassName: SingletonEnum
 * @description: 枚举实现单例
 * @author: JiangBeiPing
 * @create: 2021-07-20 14:37
 * @Version: 1.0
 **/
public enum SingletonEnum {

    //枚举元素本身就是单例
    INSTANCE;

    // 业务需要的操作
    public void doSomething(){
    }
}

2.7 容器

package com.jbp.designpattern.singleton;

import java.util.HashMap;
import java.util.Map;

/**
 * @ClassName: SingletonManager
 * @description: 容器
 * 					在开始的时候将单例类型注入到一个容器之中，
 * 在使用的时候再根据key值获取对应的实例，这种方式可以使我们很方
 * 便的管理很多单例对象，也对用户隐藏了具体实现类,降低了耦合度；
 * 但是为了避免造成内存泄漏，一般在生命周期销毁的时候也要去销毁它。
 * 
 * @author: JiangBeiPing
 * @create: 2021-07-20 14:45
 * @Version: 1.0
 **/
public class SingletonManager {

    private static Map<String, Object> map = new HashMap<>();

    private SingletonManager() {
    }

    public static void putSingleton(String key,String instance){
        if (!map.containsKey(key)){
            map.put(key,instance);
        }
    }

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

}

3. 优缺点

优点：

• 在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例
• 避免对资源的多重占用（比如写文件操作）

缺点：

• 没有接口，不能继承，与单一职责原则冲突