快速理解设计模式：单例模式深入

目录

一、单例模式的定义和应用场景

（一）定义及基本要点

（二）应用场景

二、饿汉式单例模式

（一）基本代码展示分析

（二）基本分析和建议

三、懒汉式单例模式（双重检查锁）

（一）基本代码展示分析

（二）基本分析和建议

四、静态内部类实现单例模式

（一）基本代码展示分析

（二）基本分析和建议

五、注册式单例模式

（一）枚举式单例模式代码及分析：（Effective Java推荐单例模式）

（二）容器式单例模式代码及分析：（适用于实例非常多的情况，便于管理，但是是非线程安全的）

参考书籍、文献和资料

干货分享，感谢您的阅读！

一、单例模式的定义和应用场景

（一）定义及基本要点

单例模式是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。

该模式有三个基本要点：

  • 一是这个类只能有一个实例；
  • 二是它必须自行创建这个实例；
  • 三是它必须自行向整个系统提供这个实例。

（二）应用场景

应用场景：J2EE中的ServlertContext、SerletContextConfig等、Spring框架应用中的ApplicationContext、数据库连接池等。

二、饿汉式单例模式

（一）基本代码展示分析

  1. /**
  2.  * 描述：饿汉式单例模式
  3.  * 优点：没有任何锁，执行效率高，用户体验比懒汉式单例模式更好
  4.  * 缺点：类加载的时候就初始化，不管用不用都占内存空间
  5.  * 建议：适用于单例模式较少的场景
  6.  *      如果我们在程序启动后，一定会加载到类，那么用饿汉模式实现的单例简单又实用；
  7.  *      如果我们是写一些工具类，则优先考虑使用懒汉模式，可以避免提前被加载到内存中，占用系统资源。
  8.  *
  9.  * @author yanfengzhang
  10.  * @date 2020-01-02 20:39
  11.  */
  12. public class HungrySingleton {
  13.     private final static HungrySingleton HUNGRY_SINGLETON = new HungrySingleton();
  14.  
  15.     private HungrySingleton() {
  16.     }
  17.  
  18.     public static HungrySingleton getInstance() {
  19.         return HUNGRY_SINGLETON;
  20.     }
  21. }

（二）基本分析和建议

优点：没有任何锁，执行效率高，用户体验比懒汉式单例模式更好
缺点：类加载的时候就初始化，不管用不用都占内存空间
建议：

  • 适用于单例模式较少的场景
  • 如果我们在程序启动后，一定会加载到类，那么用饿汉模式实现的单例简单又实用；
  • 如果我们是写一些工具类，则优先考虑使用懒汉模式，可以避免提前被加载到内存中，占用系统资源。

三、懒汉式单例模式（双重检查锁）

（一）基本代码展示分析

  1. /**
  2.  * 描述：懒汉式单例模式---双重检查锁
  3.  * 相比单锁而言，双重检查锁性能上虽然有提升，但是依旧用到了synchronized关键字总归要上锁，对程序性能还是存在一定的性能影响
  4.  * 不算最优--存在优化空间
  5.  *
  6.  * 建议：如果我们在程序启动后，一定会加载到类，那么用饿汉模式实现的单例简单又实用；
  7.  *      如果我们是写一些工具类，则优先考虑使用懒汉模式，可以避免提前被加载到内存中，占用系统资源。
  8.  *
  9.  * @author yanfengzhang
  10.  * @date 2020-01-02 20:53
  11.  */
  12. public class LazyDoubleCheckSingleton {
  13.     /**
  14.      * volatile 关键字可以保证线程间变量的可见性，还有一个作用就是阻止局部重排序的发生
  15.      */
  16.     private volatile static LazyDoubleCheckSingleton lazyDoubleCheckSingleton = null;
  17.  
  18.     private LazyDoubleCheckSingleton() {
  19.     }
  20.  
  21.     public static LazyDoubleCheckSingleton getInstance() {
  22.         if (null == lazyDoubleCheckSingleton) {
  23.             synchronized (LazyDoubleCheckSingleton.class) {
  24.                 if (null == lazyDoubleCheckSingleton) {
  25.                     lazyDoubleCheckSingleton = new LazyDoubleCheckSingleton();
  26.                 }
  27.             }
  28.         }
  29.         return lazyDoubleCheckSingleton;
  30.     }
  31. }

（二）基本分析和建议

相比单锁而言，双重检查锁性能上虽然有提升，但是依旧用到了synchronized关键字总归要上锁，对程序性能还是存在一定的性能影响。注意里面volatile的使用！！！

建议：

  • 如果我们在程序启动后，一定会加载到类，那么用饿汉模式实现的单例简单又实用；
  • 如果我们是写一些工具类，则优先考虑使用懒汉模式，可以避免提前被加载到内存中，占用系统资源。

四、静态内部类实现单例模式

（一）基本代码展示分析

  1. /**
  2.  * 描述：屏蔽饿汉式单例模式的内存浪费问题和双重检查锁中synchronized的性能问题
  3.  * 避免因为反射破坏单例
  4.  *
  5.  * @author yanfengzhang
  6.  * @date 2020-01-02 21:08
  7.  */
  8. public class LazyInnerClassSingleton {
  9.     /**
  10.      * 使用LazyInnerClassSingleton的时候会先默认初始化换内部类
  11.      * 如果没有使用，则内部类是不加载的
  12.      */
  13.     private LazyInnerClassSingleton() {
  14.         /*为了避免反射破坏单例，需要在构造方法中增加限制，一旦出现多次重复创建，直接抛出异常*/
  15.         if (null != Lazyholder.LAZY_INNER_CLASS_SINGLETON) {
  16.             throw new RuntimeException("创建LazyInnerClassSingleton异常，不允许创建多个实例！");
  17.         }
  18.     }
  19.  
  20.     /**
  21.      * 每一个关键字都不是多余的，static是为了使单例的空间共享，保证这个方法不会被重写、重载
  22.      */
  23.     public static final LazyInnerClassSingleton getInstance() {
  24.         /*在返回结果前，一定会先加载内部类*/
  25.         return Lazyholder.LAZY_INNER_CLASS_SINGLETON;
  26.     }
  27.  
  28.     /**
  29.      * 默认不加载
  30.      */
  31.     private static class Lazyholder {
  32.         private static final LazyInnerClassSingleton LAZY_INNER_CLASS_SINGLETON = new LazyInnerClassSingleton();
  33.     }
  34. }

（二）基本分析和建议

屏蔽饿汉式单例模式的内存浪费问题和双重检查锁中synchronized的性能问题，同时考虑避免因为反射破坏单例问题。

相对而言性能最好！

五、注册式单例模式

注册式单例模式/登记式单例模式，将每个实例都登记到一个地方，使用唯一的标识获取单例。

注册单例模式有两种：枚举式单例模式+容器式单例模式

（一）枚举式单例模式代码及分析：（Effective Java推荐单例模式）

  1. /**
  2.  * 描述：注册式单例模式/登记式单例模式，将每个实例都登记到一个地方，使用唯一的标识获取单例。
  3.  * 注册单例模式有两种：枚举式单例模式+容器式单例模式
  4.  * 此为枚举式单例模式---Effective Java推荐单例模式
  5.  *
  6.  * @author yanfengzhang
  7.  * @date 2020-01-03 09:59
  8.  */
  9. public enum EnumSingleton {
  10.     /*枚举式单例模式*/
  11.     INSTANCE;
  12.  
  13.     private Object data;
  14.  
  15.     public Object getData() {
  16.         return data;
  17.     }
  18.  
  19.     public void setData(Object data) {
  20.         this.data = data;
  21.     }
  22.  
  23.     public static EnumSingleton getInstance() {
  24.         return INSTANCE;
  25.     }
  26. }

（二）容器式单例模式代码及分析：（适用于实例非常多的情况，便于管理，但是是非线程安全的）

  1. /**
  2.  * 描述：注册式单例模式/登记式单例模式，将每个实例都登记到一个地方，使用唯一的标识获取单例。
  3.  * 注册单例模式有两种：枚举式单例模式+容器式单例模式
  4.  * 建议：容器式单例模式适用于实例非常多的情况，便于管理，但是是非线程安全的。
  5.  *
  6.  * @author yanfengzhang
  7.  * @date 2020-01-03 10:51
  8.  */
  9. public class ContainerSingleton {
  10.     private ContainerSingleton() {
  11.     }
  12.  
  13.     private static Map ioc = new ConcurrentHashMap<>();
  14.  
  15.     public static Object getBean(String className) {
  16.         synchronized (ioc) {
  17.             if (ioc.containsKey(className)) {
  18.                 return ioc.get(className);
  19.             }
  20.             Object obj = null;
  21.             try {
  22.                 obj = Class.forName(className).newInstance();
  23.                 ioc.put(className, obj);
  24.             } catch (Exception e) {
  25.                 e.printStackTrace();
  26.             }
  27.             return obj;
  28.         }
  29.     }
  30. }

参考书籍、文献和资料

1.《Sring 5 核心原理与30个类手写实战》，谭勇徳，中国公信出版社，2019.

2.极客时间课程《Java性能调优实战》，刘超，2019.

注：本文转载自blog.csdn.net的张彦峰ZYF的文章"https://zyfcodes.blog.csdn.net/article/details/105652399"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！