• 弄懂软件设计模式(一)：单例模式和策略模式

    前言

            软件设计模式和设计原则是十分重要的，所有的开发框架和组件几乎都使用到了，比如在这小节中的单例模式就在SpringBean中被使用。在这篇文章中荔枝将会仔细梳理有关单例模式和策略模式的相关知识点，其中比较重要的是掌握单例模式的常规写法。希望对有需要的小伙伴有帮助~~~

    文章目录

    前言

    一、单例模式singleton

    1.1 饿汉式

    1.2 懒汉式

    1.3 懒汉式+悲观锁

    1.4 双重检查锁

    1.5 静态内部类写法

    1.6 枚举单例 

    二、策略模型Strategy

    总结

    一、单例模式singleton

            单例模式确保仅创建一个实例且避免在同一个项目中创建多个实例。其实就是在一次类加载中，只会对当前的类对象创建一次实例，我们不能通过new方法来实例化对象，而是只能调用类对象提供的getInstance方法获取已实例化的对象。

    1.1 饿汉式

    饿汉式相对来说是使用的比较多的一种单例模式的写法，在类中静态定义一个私有变量并在类加载的时候实例化该类对象。通过在getInstance方法中返回INSTANCE实例对象。

    1. package com.mashibing.dp.singleton;
    2.  
    3. public class Mgr01 {
    4.     private static final Mgr01 INSTANCE = new Mgr01();
    5.  
    6.     private Mgr01() {};
    7.  
    8.     public static Mgr01 getInstance() {
    9.         return INSTANCE;
    10.     }
    11.  
    12.     public void m() {
    13.         System.out.println("m");
    14.     }
    15.  
    16.     public static void main(String[] args) {
    17.         Mgr01 m1 = Mgr01.getInstance();
    18.         Mgr01 m2 = Mgr01.getInstance();
    19.         System.out.println(m1 == m2);
    20.     }
    21. }

    饿汉式是立即加载的，除了预防反序列化的问题之外几乎没有缺点，而且它是线程安全的，操作简单。

    1.2 懒汉式

    懒汉式不会在加载类的时候就实例化对象，是懒加载的(按需加载)，但是会出现线程安全的问题。 

    比如这里两个线程同时打到INSTANCE上，就可能会有同时new出实例对象的风险，因此线程不安全。下面的示例demo中可以看到一个lambda表达式描述的方法。Lambda表达式是对线程Runnable接口匿名内部类的一种简写，这是因为我们这里在Runnable中只写一种内部方法

    1. package com.mashibing.dp.singleton;
    2.  
    3. public class Mgr03 {
    4.     private static Mgr03 INSTANCE;
    5.  
    6.     private Mgr03() {
    7.     }
    8.     /**
    9.      * 懒汉式
    10.      */
    11.     public static Mgr03 getInstance() {
    12.         if (INSTANCE == null) {
    13.             try {
    14.                 Thread.sleep(1);
    15.             } catch (InterruptedException e) {
    16.                 e.printStackTrace();
    17.             }
    18.             INSTANCE = new Mgr03();
    19.         }
    20.         return INSTANCE;
    21.     }
    22.  
    23.     public void m() {
    24.         System.out.println("m");
    25.     }
    26.  
    27.     public static void main(String[] args) {
    28.         for(int i=0; i<100; i++) {
    29.             new Thread(()->
    30.                 System.out.println(Mgr03.getInstance().hashCode())
    31.             ).start();
    32.         }
    33.     }
    34. }

     这里的new Thread()原本写法是

    1.     new Thread(new Runnable() {
    2.         @Override
    3.         public void run() {
    4.             System.out.println(Mgr03.getInstance().hashCode())
    5.         }
    6.     }).start();

    1.3 懒汉式+悲观锁

    懒汉式加锁其实比较简单，直接使用synchronized关键字修饰加上悲观锁就可以了，操作比较简单，也比较完好地解决了线程安全问题，但这却是以牺牲效率为前提的，同时也并非序列化安全和反射安全的。

    1. package com.mashibing.dp.singleton;
    2.  
    3. public class Mgr04 {
    4.     private static Mgr04 INSTANCE;
    5.  
    6.     private Mgr04() {
    7.     }
    8.  
    9.     /**
    10.      * 懒汉式+同步锁
    11.      * @return
    12.      */
    13.     public static synchronized Mgr04 getInstance() {
    14.         if (INSTANCE == null) {
    15.             try {
    16.                 Thread.sleep(1);
    17.             } catch (InterruptedException e) {
    18.                 e.printStackTrace();
    19.             }
    20.             INSTANCE = new Mgr04();
    21.         }
    22.         return INSTANCE;
    23.     }
    24.  
    25.     public void m() {
    26.         System.out.println("m");
    27.     }
    28.  
    29.     public static void main(String[] args) {
    30.         for(int i=0; i<100; i++) {
    31.             new Thread(()->{
    32.                 System.out.println(Mgr04.getInstance().hashCode());
    33.             }).start();
    34.         }
    35.     }
    36. }

    1.4 双重检查锁

            前面我们为了解决懒汉式带来的线程安全问题加入了锁机制，但却带来了代码效率的下降。这里可以使用双重检查的机制来解决代码效率的问题，优化了代码性能，同时也保证了线程安全和懒加载的机制。但实现起来确实略显复杂，调试也比较困难。

    1. package com.mashibing.dp.singleton;
    2.  
    3. public class Mgr06 {
    4.     //这里需要加上volatile的原因是因为Java中在编译中指令重排比较频繁，如果不加volatile会出现问题，
    5.     private static volatile Mgr06 INSTANCE; //JIT
    6.  
    7.     private Mgr06() {
    8.     }
    9.     /**
    10.      *双重检查单例写法
    11.      * @return
    12.      */
    13.     public static Mgr06 getInstance() {
    14.         if (INSTANCE == null) {
    15.             //双重检查
    16.             synchronized (Mgr06.class) {
    17.                 if(INSTANCE == null) {
    18.                     try {
    19.                         Thread.sleep(1);
    20.                     } catch (InterruptedException e) {
    21.                         e.printStackTrace();
    22.                     }
    23.                     INSTANCE = new Mgr06();
    24.                 }
    25.             }
    26.         }
    27.         return INSTANCE;
    28.     }
    29.  
    30.     public void m() {
    31.         System.out.println("m");
    32.     }
    33.  
    34.     public static void main(String[] args) {
    35.         for(int i=0; i<100; i++) {
    36.             new Thread(()->{
    37.                 System.out.println(Mgr06.getInstance().hashCode());
    38.             }).start();
    39.         }
    40.     }
    41. }

    这里需要注意的是在静态变量中INSTANCE需要加上volatile关键字修饰！

    volatile关键子的作用

    • 确保INSTANCE变量的可见性，防止出现空指针异常的问题

            被volatile修饰的变量在线程访问时会被强制从主内存中读取变量的值而不从本地缓存中读取，保证共享变量的可见性和有序性，在对该变量进行修改后线程会强制将更新后的值刷回主内存，而不仅仅更新线程的本地缓存。出现空指针异常的问题可能是因为其它线程无立即获取修改后的未被volatile关键字修饰的变量值。

    • 防止指令重排

            指令重排是CPU为了提高程序执行效率而执行的操作，如果INSTANCE变量未被volatile修饰，那么可能无法保证线程安全。

    1.5 静态内部类写法

             可以看到静态内部类的写法会在对象类中自定义一个私有的静态内部类，在其中实例化对象并赋值给一个静态常量。既实现了实例化对象的懒加载，同时也保证了线程安全。该类的缺点是对于传参的限制在某些场景下可能不太使用。

    1. package com.mashibing.dp.singleton;
    2.  
    3. public class Mgr07 {
    4.  
    5.     private Mgr07() {
    6.     }
    7.  
    8.     private static class Mgr07Holder {
    9.         private final static Mgr07 INSTANCE = new Mgr07();
    10.     }
    11.  
    12.     /**
    13.      * 静态内部类的写法
    14.      * @return
    15.      */
    16.     public static Mgr07 getInstance() {
    17.         return Mgr07Holder.INSTANCE;
    18.     }
    19.  
    20.     public void m() {
    21.         System.out.println("m");
    22.     }
    23.  
    24.     public static void main(String[] args) {
    25.         for(int i=0; i<100; i++) {
    26.             new Thread(()->{
    27.                 System.out.println(Mgr07.getInstance().hashCode());
    28.             }).start();
    29.         }
    30.     }
    31.  
    32.  
    33. }

    1.6 枚举单例 

    枚举单例是最完美的单例模式，有效的解决了Java类的反序列化问题，实现了序列安全和反射安全。但枚举单例并不是懒加载的，也不能被继承。

    1. package com.mashibing.dp.singleton;
    2.  
    3. /**
    4.  * 不仅可以解决线程同步，还可以防止反序列化。
    5.  */
    6. public enum Mgr08 {
    7.  
    8.     INSTANCE;
    9.  
    10.     public void m() {}
    11.  
    12.     public static void main(String[] args) {
    13.         for(int i=0; i<100; i++) {
    14.             new Thread(()->{
    15.                 System.out.println(Mgr08.INSTANCE.hashCode());
    16.             }).start();
    17.         }
    18.     }
    19.  
    20. }

    非枚举类的单例模式会出现反序列化的问题，这时因为我们可以利用Java的反射机制通过Java中的.class文件加载class对象

    枚举单例不能够被反序列化的原因：枚举类没有构造方法。

    这里有关双重检查锁参考了掘金大佬的文章，出处如下：

    https://juejin.cn/post/7206529406612062268?searchId=20230905212839127143297911190A3F76#heading-16

    二、策略模型Strategy

            策略模型比较简单，在日常开发中的使用也比较多，策略模型中一般封装的是实现一个方法的不同执行方式。策略模型将对象和行为分开，属于行为型模式。行为被分为了行为策略接口和实现行为的类。

    main文件 

    主程序调用比较类Sort，传入类对象和相应的比较器接口的实现即可。 

    1. package com.mashibing.dp.strategy;
    2.  
    3. import java.util.Arrays;
    4.  
    5. /**
    6.  * writing tests first!
    7.  * extreme programming
    8.  */
    9. public class Main {
    10.     public static void main(String[] args) {
    11.         Cat[] a = {new Cat(3, 3), new Cat(5, 5), new Cat(1, 1)};
    12.         Sorter sorter = new Sorter<>();
    13. //        Dog[] b = {new Dog(3), new Dog(5), new Dog(1)};
    14. //        Sorter sorter = new Sorter<>();
    15.        
    16.         /**
    17.          * 策略模式的选择，通过类加载的方式实现功能，代码的拓展性更强
    18.          */
    19.         sorter.sort(a,new CatWeightComparator());
    20.         System.out.println(Arrays.toString(a));
    21.         sorter.sort(a,new CatHeightComparator());
    22.         System.out.println(Arrays.toString(a));
    23.     }
    24. }

    Sort类

    自定义一个策略选择类，在其中调用已经被重写了的comparator接口中的compare方法实现对传入的比较类的策略模型的调用。 

    1. package com.mashibing.dp.strategy;
    2.  
    3. public class Sorter {
    4.  
    5.     public void sort(T[] arr, Comparator comparator) {
    6.         for(int i=0; i1; i++) {
    7.             int minPos = i;
    8.  
    9.             for(int j=i+1; j
    10.                 minPos = comparator.compare(arr[j],arr[minPos])==-1 ? j : minPos;
    11.             }
    12.             swap(arr, i, minPos);
    13.         }
    14.     }
    15.  
    16. }

    策略实现类

    策略接口需要实现Java.util中的Comparator接口并重写其中的compare方法实现对象类的策略逻辑封装。

    1. package com.mashibing.dp.strategy;
    2.  
    3. public class CatHeightComparator implements Comparator {
    4.     @Override
    5.     public int compare(Cat o1, Cat o2) {
    6.         if(o1.height > o2.height) return -1;
    7.         else if (o1.height < o2.height) return 1;
    8.         else return 0;
    9.     }
    10. }

            其实最简单的策略模型的应用就是通过 if...else... 来判断执行策略，但是这种方式相比而言比较混乱，可拓展性不是很好，因此需要通过接口实现类和Java泛型来自定义一些策略以供选择。

    总结

            上面的内容中荔枝主要梳理了单例模式和策略模式，这是二十三种软件设计模式中的两种，理解几种典型的单例模式的写法，接下来的文章中荔枝也会持续学习并整理输出，希望未来越来越好哈哈哈哈哈~~~

    今朝已然成为过去，明日依然向往未来！我是小荔枝，在技术成长的路上与你相伴，码文不易，麻烦举起小爪爪点个赞吧哈哈哈~~~ 比心心♥~~~

  • 相关阅读:
    安装虚拟机及centos7
    regionserver请求不均匀
    Shiro安全框架
    内存卡删除的文件如何恢复？99%的人都用过这个方案
    pip某些包发生SSL错误
    ffmpeg云服务器推流
    Web前端：2022年最新web开发技术
    C++：什么情况下函数应该声明为纯虚函数
    流媒体分析之srt 协议srs 服务器数据收发
    vue-devTools Chrome安装配置
  • 原文地址：https://blog.csdn.net/qq_62706049/article/details/132694837