意图

保证一个类仅有一个实例，并提供一个全局访问结点。

适用性

  1. 类只能有一个实例，客户可以从一个众所周知的结点访问它。
  2. 当这个唯一实例通过子类化可扩展的，客户无需更改代码就能使用一个扩展的实例。

效果

  1. 对唯一实例的受控访问——单例类封装其唯一实例，所以可以控制客户何时及怎样访问它。
  2. 缩小名字空间——单例模式是一种对全局变量的改进.
  3. 允许对操作和表示的精化——Singleton类可以有子类，允许在运行时配置应用。
  4. 允许可变数目的实例——可以用相同的方法控制实例的数目。
  5. 比类操作更灵活

实现方式

饿汉式

  1. /**
  2.  * 饿汉式实现单例模式
  3.  *
  4.  * @author Jinhua
  5.  * @date 2020/8/22 22:47
  6.  */
  7. public class SingletonHungry implements MySingleton {
  9.     /**
  10.      * 类加载准备阶段的时候就进行初始化
  11.      */
  12.     private static final SingletonHungry INSTANCE = new SingletonHungry();
  14.     private SingletonHungry() {
  16.     }
  18.     public static SingletonHungry getInstance() {
  19.         return INSTANCE;
  20.     }
  22.     @Override
  23.     public void doSomething() {
  24.         System.out.println(this + "\t饿汉实现单例模式");
  25.     }
  26. }

懒汉式（线程不安全）

  1. /**
  2.  * 懒汉模式单例（线程不安全）
  3.  *
  4.  * @author Jinhua
  5.  * @date 2020/8/22 22:49
  6.  */
  7. public class SingletonLazy implements MySingleton {
  9.     private static SingletonLazy instance = null;
  11.     private SingletonLazy() {
  13.     }
  15.     /**
  16.      * 模拟多线程下不安全的问题
  17.      *
  18.      * @return 返回单例对象
  19.      * @throws InterruptedException 中断异常
  20.      */
  21.     public static SingletonLazy getInstance() throws InterruptedException {
  22.         if (instance == null) {
  23.             // 睡眠用于模拟线程不安全的问题
  24.             Thread.sleep(5000);
  25.             instance = new SingletonLazy();
  26.         }
  27.         return instance;
  28.     }
  30.     @Override
  31.     public void doSomething() {
  32.         System.out.println(this + "\t懒汉实现单例模式.");
  33.     }
  34. }

懒汉式（线程安全）

  1. /**
  2.  * 懒汉模式单例（线程安全）
  3.  *
  4.  * @author Jinhua
  5.  * @date 2020/8/22 22:52
  6.  */
  7. public class SingletonLazyThread implements MySingleton {
  9.     private static SingletonLazyThread instance;
  11.     private SingletonLazyThread() {
  13.     }
  15.     /**
  16.      * 测试多线程环境下线程安全的懒汉实现单例
  17.      *
  18.      * @return 单例对象
  19.      * @throws InterruptedException 中断异常
  20.      */
  21.     public static synchronized SingletonLazyThread getInstance() throws InterruptedException {
  22.         if (instance == null) {
  23.             // 睡眠用于模拟线程的问题
  24.             Thread.sleep(5000);
  25.             instance = new SingletonLazyThread();
  26.         }
  27.         return instance;
  28.     }
  30.     @Override
  31.     public void doSomething() {
  32.         System.out.println(this + "\t线程安全的懒汉单例模式.");
  33.     }
  34. }

双重检查模式

  1. /**
  2.  * 双重检查的单例模式
  3.  *
  4.  * @author Jinhua
  5.  * @date 2020/8/22 22:39
  6.  */
  7. public class SingletonDoubleCheck implements MySingleton {
  9.     private static volatile SingletonDoubleCheck instance = null;
  11.     private SingletonDoubleCheck() {
  13.     }
  15.     public static SingletonDoubleCheck getInstance() {
  16.         // 避免多次进入同步判断，影响性能
  17.         if (instance == null) {
  18.             synchronized (SingletonDoubleCheck.class) {
  19.                 // 同步块中的判断，保证唯一
  20.                 if (instance == null) {
  21.                     instance = new SingletonDoubleCheck();
  22.                 }
  23.             }
  24.         }
  25.         return instance;
  26.     }
  28.     @Override
  29.     public void doSomething() {
  30.         System.out.println(this + "\t双重检查单例模式");
  31.     }
  32. }

枚举单例

  1. /**
  2.  * 枚举实现单例
  3.  *
  4.  * @author Jinhua
  5.  * @date 2020/8/22 23:03
  6.  */
  7. public enum SingletonEnum implements MySingleton {
  8.     /**
  9.      * 单例的枚举
  10.      */
  11.     INSTANCE;
  13.     private Object readResolve() throws ObjectStreamException {
  14.         return INSTANCE;
  15.     }
  17.     @Override
  18.     public void doSomething() {
  19.         System.out.println(this + "\t枚举单例模式.");
  20.     }
  22.     public static MySingleton getInstance() {
  23.         return SingletonEnum.INSTANCE;
  24.     }
  25. }

静态内部类单例

  1. /**
  2.  * 静态内部实现类单例模式
  3.  *
  4.  * @author Jinhua
  5.  * @date 2020/8/22 23:02
  6.  */
  7. public class SingletonStaticInnerClass implements MySingleton {
  9.     private SingletonStaticInnerClass() {
  11.     }
  13.     public static SingletonStaticInnerClass getInstance() {
  14.         return SingletonHolder.S_INSTANCE;
  15.     }
  17.     @Override
  18.     public void doSomething() {
  19.         System.out.println(this + "\t静态内部类实现单例模式.");
  20.     }
  22.     /**
  23.      * 静态内部类中引用当前对象
  24.      */
  25.     private static class SingletonHolder {
  26.         private static final SingletonStaticInnerClass S_INSTANCE = new SingletonStaticInnerClass();
  27.     }
  28. }

管理单例对象

容器管理单例对象

  1. /**
  2.  * 使用容器管理单例对象
  3.  *
  4.  * @author Jinhua
  5.  * @date 2020/8/22 23:05
  6.  */
  7. public class SingletonManager {
  9.     /**
  10.      * 存储单例对象的 map
  11.      */
  12.     private static final Map<String, Object> OBJ_MAP = new HashMap<>();
  14.     private SingletonManager() {
  16.     }
  18.     /**
  19.      * 注册到 map 中的方法
  20.      * @param key 注册的键
  21.      * @param instance 单实例
  22.      */
  23.     public static void registerService(String key, Object instance) {
  24.         if (!OBJ_MAP.containsKey(key)) {
  25.             OBJ_MAP.put(key, instance);
  26.         }
  27.     }
  29.     /**
  30.      * 获取根据键单实例的服务
  31.      * @param key 键
  32.      * @return 单例
  33.      */
  34.     public static Object getService(String key) {
  35.         return OBJ_MAP.get(key);
  36.     }
  37. }