• 设计模式-单例模式

    目录

    设计模式原则

     一、抽象工厂模式

    1.1 定义

    1.2 类图

    1.3 优点

    1.4 例子

    二、单例模式

    2.1 定义

    2.2 优缺点

    2.3 应用场景

    Runtime.java

    DefaultSingletonBeanRegistry.java

    ReactiveAdapterRegistry.java

    Currency.java

    2.4 实现方式

    1、懒汉模式

    2、恶汉模式

    3、静态内部类

    反射打破单例模式情况

    设计模式原则

    开闭原则 对扩展开放，对修改关闭

    单⼀职责原则 ⼀个类只负责⼀个功能领域中的相应职责

    ⾥⽒替换原则 所有引⽤基类的地⽅必须能透明地使⽤其⼦类的对象

    依赖倒置原则 依赖于抽象，不能依赖于具体实现

    接⼝隔离原则 类之间的依赖关系应该建⽴在最⼩的接⼝上

    合成/聚合复⽤原则 尽量使⽤合成/聚合，⽽不是通过继承达到复⽤的⽬的

    迪⽶特法则 ⼀个软件实体应当尽可能少的与其他实体发⽣相互作⽤

     一、抽象工厂模式

    1.1 定义

    抽象工厂模式（Abstract FactoryPattern）围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂

    1.2 类图

    1.3 优点

    单一职责

    开闭原则 

    1.4 例子

    Connection.java

    二、单例模式

    2.1 定义

    保证一个类只有一个实例，并且提供一个全局访问点

    2.2 优缺点

    优点：一个单例类只存在一个实例，减少开销、避免创建和销毁是对资源的多重占用

    确定：没有抽象层、难以扩展、违反设计模式思想的单一职责原则。

    2.3 应用场景

    线程池、连接池等情况

    Runtime.java

    标准的恶汉模式

    DefaultSingletonBeanRegistry.java

    懒汉模式

    ReactiveAdapterRegistry.java

    volatile的懒汉模式

    Currency.java

    带序列化和反序列化

    2.4 实现方式

    1、懒汉模式

    需要优化：线程安全、双重校验、防止指令重排 voilatile

    为什么要用voilatile？

    因为可见性、防止指令重排，new过程不是原子操作。会经历1、开启堆空间 2、构造方法初始化对象 3、引用变量指向堆内存空间

    1. package com.example.demo.designPattern.singleton;
    2.  
    3. /**
    4.  * @author 10450
    5.  * @description 懒汉模式
    6.  * 并发情况下，有可能
    7.  * @date 2022/9/15 13:58
    8.  */
    9. public class LazySingletonTest {
    10.     public static void main(String[] args){
    11.         new Thread(()->{
    12.             LazySingleton intance = LazySingleton.getSingleton();
    13.             System.out.println(intance);
    14.         }).start();
    15.  
    16.         new Thread(()->{
    17.             LazySingleton intance = LazySingleton.getSingleton();
    18.             System.out.println(intance);
    19.         }).start();
    20.  
    21.         new Thread(()->{
    22.             LazySafeSingleton intance = LazySafeSingleton.getSingleton();
    23.             System.out.println(intance);
    24.         }).start();
    25.  
    26.         new Thread(()->{
    27.             LazySafeSingleton intance = LazySafeSingleton.getSingleton();
    28.             System.out.println(intance);
    29.         }).start();
    30.  
    31.         new Thread(()->{
    32.             LazyVolatileSingleton intance = LazyVolatileSingleton.getSingleton();
    33.             System.out.println(intance);
    34.         }).start();
    35.  
    36.         new Thread(()->{
    37.             LazyVolatileSingleton intance = LazyVolatileSingleton.getSingleton();
    38.             System.out.println(intance);
    39.         }).start();
    40.     }
    41. }
    42.  
    43. /**
    44.  * 多线程不安全
    45.  */
    46. class LazySingleton{
    47.     private static LazySingleton instance;
    48.     private LazySingleton(){
    49.     }
    50.     public static LazySingleton getSingleton(){
    51.         if(instance==null){
    52.             try{
    53.                 Thread.sleep(5000);
    54.                 instance =  new LazySingleton();
    55.             }catch (InterruptedException e) {
    56.                 e.printStackTrace();
    57.             }
    58.         }
    59.         return instance;
    60.     }
    61. }
    62. /**
    63.  * 多线程安全,但是指令重排有问题
    64.  */
    65. class LazySafeSingleton{
    66.     private static LazySafeSingleton instance;
    67.     private LazySafeSingleton(){
    68.     }
    69.     public static LazySafeSingleton getSingleton(){
    70.         if(instance==null){
    71.             synchronized (LazySafeSingleton.class){
    72.                 if(instance==null){
    73.                     try{
    74.                         Thread.sleep(5000);
    75.                         instance =  new LazySafeSingleton();
    76.                     }catch (InterruptedException e) {
    77.                         e.printStackTrace();
    78.                     }
    79.                 }
    80.             }
    81.         }
    82.         return instance;
    83.     }
    84. }
    85.  
    86. /**
    87.  * 防止指令重排
    88.  */
    89. class LazyVolatileSingleton{
    90.     private volatile static LazyVolatileSingleton instance;
    91.     private LazyVolatileSingleton(){
    92.     }
    93.     public static LazyVolatileSingleton getSingleton(){
    94.         if(instance==null){
    95.             synchronized (LazyVolatileSingleton.class){
    96.                 if(instance==null){
    97.                     try{
    98.                         Thread.sleep(5000);
    99.                         instance =  new LazyVolatileSingleton();
    100.                     }catch (InterruptedException e) {
    101.                         e.printStackTrace();
    102.                     }
    103.                 }
    104.             }
    105.         }
    106.         return instance;
    107.     }
    108. }
    109.  
    110.  
    111.

    2、恶汉模式

    类加载的初始化节点完成实例初始化。本质就是JVM类加载机制，保证实例唯一性。

    类加载是就创建对象、比较常用，但是容易浪费空间。

    优点：线程安全、没有加锁，执行效率快

    缺点：浪费空间

    类加载过程:

    1. 加载二进制字节码数据到内存中，生成对应class数据结构
    2. 连接：a:验证、b:准备（给类的静态成员变量赋默认值），c:解析
    3. 初始化：给类静态变量赋初值
      1. package com.example.demo.designPattern.singleton;
      2.  
      3. /**
      4.  * @author 10450
      5.  * @description 恶汉模式
      6.  * 类加载的时候完成初始化
      7.  * @date 2022/9/15 14:23
      8.  */
      9. public class HungrySingletonTest {
      10.     public static void main(String[] args) {
      11.         System.out.println(HungrySingleton.getInstance());
      12.         System.out.println(HungrySingleton.getInstance());
      13.     }
      14. }
      15.  
      16. class HungrySingleton{
      17.     private static HungrySingleton  instance = new HungrySingleton();
      18.     private HungrySingleton(){
      19.     }
      20.     public static HungrySingleton getInstance(){
      21.         return instance;
      22.     }
      23. }

      3、静态内部类

         优点：懒加载，线程安全，效率较⾼，实现简单

    • 本质上利用类的加载机制保证线程安全
    • 只要在实际使用的时候才会触发累的初始化，也是懒加载的一种
      1. package com.example.demo.designPattern.singleton;
      2.  
      3. import java.lang.reflect.Constructor;
      4. import java.lang.reflect.InvocationTargetException;
      5.  
      6. /**
      7.  * @author 10450
      8.  * @description 静态内部类
      9.  * 可以防止通过反射，实现多利
      10.  * @date 2022/9/15 14:28
      11.  */
      12. public class InnerClassSingletonTest {
      13.     public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
      14.         new Thread(()->{
      15.             System.out.println(InnerClassSingleton.getInstance());
      16.         }).start();
      17.  
      18.         new Thread(()->{
      19.             System.out.println(InnerClassSingleton.getInstance());
      20.         }).start();
      21.         
      22.         //利用反射方式创建类对象打破单例模式，实现多利
      23.         Constructor declaredConstructor = InnerClassSingleton.class.getDeclaredConstructor();
      24.         declaredConstructor.setAccessible(true);
      25.         InnerClassSingleton innerClassSingleton = declaredConstructor.newInstance();
      26.         InnerClassSingleton instance = InnerClassSingleton.getInstance();
      27.         System.out.println(innerClassSingleton);
      28.         System.out.println(instance);
      29.     }
      30. }
      31.  
      32. class InnerClassSingleton{
      33.     private static class InnerClassSingletonHolder{
      34.         private static InnerClassSingleton instance = new InnerClassSingleton();
      35.     }
      36.     private InnerClassSingleton(){
      37.     }
      38.     public static InnerClassSingleton getInstance(){
      39.         try {
      40.             System.out.println(1);
      41.             Thread.sleep(8000);
      42.             System.out.println(2);
      43.         } catch (InterruptedException e) {
      44.             e.printStackTrace();
      45.         }
      46.         return InnerClassSingletonHolder.instance;
      47.     }
      48. }

      反射打破单例模式情况

    通过反射方式创建类，可以打破单例模式，实现多例效果，

    【恶汉模式】、【内部类模式】可以判断防止多例

    1. package com.example.demo.designPattern.singleton;
    2.  
    3. import java.lang.reflect.Constructor;
    4. import java.lang.reflect.InvocationTargetException;
    5.  
    6. /**
    7.  * @author 10450
    8.  * @description 反射攻击
    9.  * @date 2022/9/15 15:03
    10.  */
    11. public class InnerClassReflexSingletonTest {
    12.     public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    13.         //单例保护防止多利情况下：
    14.         Constructor declaredConstructor = InnerClassProtectSingleton.class.getDeclaredConstructor();
    15.         declaredConstructor.setAccessible(true);
    16.         InnerClassProtectSingleton innerClassSingleton = declaredConstructor.newInstance();
    17.         InnerClassProtectSingleton instance = InnerClassProtectSingleton.getInstance();
    18.         System.out.println(innerClassSingleton);
    19.         System.out.println(instance);
    20.     }
    21. }
    22.  
    23. /**
    24.  * 防止多例
    25.  */
    26. class InnerClassProtectSingleton {
    27.     private static class InnerClassSingletonHolder {
    28.         private static InnerClassProtectSingleton instance = new InnerClassProtectSingleton();
    29.     }
    30.  
    31.     private InnerClassProtectSingleton() {
    32.         //添加校验，抛异常
    33.         if (InnerClassSingletonHolder.instance != null) {
    34.             throw new RuntimeException("单例模式，不运行重复创建");
    35.         }
    36.     }
    37.  
    38.     public static InnerClassProtectSingleton getInstance() {
    39.         return InnerClassProtectSingleton.InnerClassSingletonHolder.instance;
    40.     }
    41. }

  • 相关阅读:
    ALL in Boom 日志记录 (ing ...
    《XSS-Labs》01. Level 1~10
    《Docker Compose入门：多容器应用的定义和管理》
    AMD CPU Nvidia GPU Ubuntu 黑屏网络故障案例分享
    LabVIEW 使用VISA Close真的关闭COM口了吗
    01-自动内存管理机制
    淘宝API接口，获取数据
    Vue3从入门到精通(三)
    学习ASP.NET Core Blazor编程系列七——新增图书
    【深度学习入门】- 用电路思想解释感知机
  • 原文地址：https://blog.csdn.net/chenlu4ever/article/details/126869902