• 设计模式——创建型模式（单例模式）

    目录

    1.饿汉式

    1.1 静态变量创建类对象

    1.2 静态代码块中创建该类对象

    2.懒汉式

    2.1线程不安全

    2.2 线程安全

    2.3 双重检查方式

    2.4 静态内部类方式

    测试类

    3. 枚举单例

    3.1 枚举方式

    3.2 原理

    4.破坏单例模式

    4.1序列化反序列化破坏

    4.2反射破坏

    5.解决单例模式破坏

    5.1解决序列化反序列化破坏

    5.2解决反射破坏

    5.3还可以第二次用反射破坏

    1.饿汉式

    1.1 静态变量创建类对象

    1. /**
    2.  * 饿汉式：静态变量创建类的对象
    3.  */
    4. public class Singleton {
    5.     //私有构造方法
    6.     private Singleton() {}
    7.  
    8.     //在成员位置创建该类的对象
    9.     private static Singleton instance = new Singleton();
    10.  
    11.     //对外提供静态方法获取该对象
    12.     public static Singleton getInstance() {
    13.         return instance;
    14.     }
    15. }
    16.  
    17.  
    18. public class Client {
    19.     public static void main(String[] args) {
    20.         Singleton instance1 = Singleton.getInstance();
    21.         Singleton instance2 = Singleton.getInstance();
    22.         System.out.println(instance1 == instance2);//true
    23.     }
    24. }

    1.2 静态代码块中创建该类对象

    1. /**
    2.  * 饿汉式：在静态代码块中创建该类对象
    3.  */
    4. public class Singleton {
    5.  
    6.     //私有构造方法
    7.     private Singleton() {}
    8.  
    9.     //在成员位置创建该类的对象
    10.     private static Singleton instance;
    11.  
    12.     static {
    13.         instance = new Singleton();
    14.     }
    15.  
    16.     //对外提供静态方法获取该对象
    17.     public static Singleton getInstance() {
    18.         return instance;
    19.     }
    20. }
    21.  
    22.  
    23. public class Client {
    24.     public static void main(String[] args) {
    25.         Singleton instance1 = Singleton.getInstance();
    26.         Singleton instance2 = Singleton.getInstance();
    27.         System.out.println(instance1 == instance2);//true
    28.     }
    29. }

    2.懒汉式

    2.1线程不安全

    1. /**
    2.  * 懒汉式：线程不安全
    3.  */
    4. public class Singleton {
    5.     //私有构造方法
    6.     private Singleton() {
    7.         System.out.println(Thread.currentThread().getName() + "OK");
    8.     }
    9.  
    10.     //在成员位置创建该类的对象
    11.     private static Singleton instance;
    12.  
    13.     //对外提供静态方法获取该对象
    14.     public static Singleton getInstance() {
    15.  
    16.         if (instance == null) {
    17.             instance = new Singleton();
    18.         }
    19.         return instance;
    20.     }
    21. }

    2.2 线程安全

    1. /**
    2.  * 懒汉式：线程安全！！！
    3.  */
    4. public class Singleton {
    5.     //私有构造方法
    6.     private Singleton() {
    7.         System.out.println(Thread.currentThread().getName()+"OK");
    8.     }
    9.  
    10.     //在成员位置创建该类的对象
    11.     private static Singleton instance;
    12.  
    13.     //对外提供静态方法获取该对象
    14.     public static synchronized Singleton getInstance() {
    15.  
    16.         if(instance == null) {
    17.             instance = new Singleton();
    18.         }
    19.         return instance;
    20.     }
    21. }

    2.3 双重检查方式

    1. /**
    2.  * 双重检查方式
    3.  * 对于getInstance()方法来说，绝大部分的操作都是读操作，读操作是线程安全的，
    4.  * 所以我们没必让每个线程必须持有锁才能调用该方法，我们需要调整加锁的时机。
    5.  *
    6.  * 在多线程的情况下，可能会出现空指针问题，出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作。
    7.  * 需要使用volatile关键字，volatile关键字可以保证可见性和有序性。
    8.  */
    9. public class Singleton {
    10.  
    11.     //私有构造方法
    12.     private Singleton() {
    13.         System.out.println(Thread.currentThread().getName()+"OK");
    14.     }
    15.  
    16.     private static volatile Singleton instance;//volatile关键字可以保证可见性和有序性。
    17.  
    18.     //对外提供静态方法获取该对象
    19.     public static Singleton getInstance() {
    20.         //第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例
    21.         if(instance == null) {
    22.             synchronized (Singleton.class) {
    23.                 //抢到锁之后再次判断是否为null
    24.                 if(instance == null) {
    25.                     instance = new Singleton();
    26.                     /**
    27.                      * 1.分配内存空间
    28.                      * 2.执行构造方法，初始化对象
    29.                      * 3.把这个对象指向这个空间
    30.                      *
    31.                      * A线程：由于指令重排，执行顺序为132
    32.                      * B线程：发现空间已经占用了，直接返回，但此时LazyMan还没有完成构造，出现空指针
    33.                      */
    34.                 }
    35.             }
    36.         }
    37.         return instance;
    38.     }
    39. }

    2.4 静态内部类方式

    1. /**
    2.  * 静态内部类方式
    3.  *
    4.  * ​第一次加载Singleton类时不会去初始化INSTANCE，
    5.  * 只有第一次调用getInstance，虚拟机加载SingletonHolder并初始化INSTANCE，
    6.  * 这样不仅能确保线程安全，也能保证Singleton类的唯一性。
    7.  *
    8.  * 静态内部类单例模式是一种优秀的单例模式，是开源项目中比较常用的一种单例模式。
    9.  * 在没有加任何锁的情况下，保证了多线程下的安全，并且没有任何性能影响和空间的浪费。
    10.  */
    11. public class Singleton {
    12.  
    13.     //私有构造方法
    14.     private Singleton() {
    15.         System.out.println(Thread.currentThread().getName() + "OK");
    16.     }
    17.  
    18.     //静态内部类
    19.     private static class SingletonHolder {
    20.         private static final Singleton INSTANCE = new Singleton();
    21.     }
    22.  
    23.     //对外提供静态方法获取该对象
    24.     public static Singleton getInstance() {
    25.         return SingletonHolder.INSTANCE;
    26.     }
    27. }

    测试类

    1. public class Client {
    2.     public static void main(String[] args) {
    3.         for (int i = 0; i < 10; i++) {
    4.             new Thread(()->{
    5.                 Singleton.getInstance();
    6.             }).start();
    7.         }
    8.     }
    9. }

    3. 枚举单例

    3.1 枚举方式

    1. /**
    2.  * 枚举方式
    3.  */
    4. public enum Singleton {
    5.     INSTANCE;
    6.  
    7.     public static Singleton getInstance() {
    8.         return INSTANCE;
    9.     }
    10. }
    11.  
    12.  
    13. public class Client {
    14.     public static void main(String[] args) {
    15.         Singleton instance1 = Singleton.INSTANCE;
    16.         Singleton instance2 = Singleton.INSTANCE;
    17.         System.out.println(instance1==instance2);//true
    18.     }
    19. }

    3.2 原理

    1. import java.lang.reflect.Constructor;
    2. import java.lang.reflect.InvocationTargetException;
    3.  
    4. /**
    5.  * 尝试反射破坏
    6.  */
    7. public class Test {
    8.     public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    9.         Constructor declaredConstructor = Singleton.class.getDeclaredConstructor(null);
    10.         declaredConstructor.setAccessible(true);
    11.         Singleton instance = declaredConstructor.newInstance();
    12.         System.out.println(instance);//NoSuchMethodException，没有空参构造方法
    13.     }
    14. }

    1. import java.lang.reflect.Constructor;
    2. import java.lang.reflect.InvocationTargetException;
    3.  
    4. /**
    5.  * 尝试反射破坏
    6.  */
    7. public class Test2 {
    8.     public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    9.         Singleton instance1 = Singleton.getInstance();
    10.         Constructor declaredConstructor = Singleton.class.getDeclaredConstructor(String.class, int.class);
    11.         declaredConstructor.setAccessible(true);
    12.         Singleton instance2 = declaredConstructor.newInstance();
    13.         System.out.println(instance1);
    14.         System.out.println(instance2);//IllegalArgumentException: Cannot reflectively create enum objects
    15.     }
    16. }

    4.破坏单例模式

    4.1序列化反序列化破坏

    1. import java.io.Serializable;
    2.  
    3. /**
    4.  * 静态内部类方式
    5.  */
    6. public class Singleton implements Serializable{
    7.  
    8.     //私有构造方法
    9.     private Singleton() {
    10.     }
    11.  
    12.     //静态内部类
    13.     private static class SingletonHolder {
    14.         private static final Singleton INSTANCE = new Singleton();
    15.     }
    16.  
    17.     //对外提供静态方法获取该对象
    18.     public static Singleton getInstance() {
    19.         return SingletonHolder.INSTANCE;
    20.     }
    21. }
    1. import java.io.FileInputStream;
    2. import java.io.FileOutputStream;
    3. import java.io.ObjectInputStream;
    4. import java.io.ObjectOutputStream;
    5.  
    6. /**
    7.  * 序列化反序列化破坏单例模式
    8.  */
    9. public class Test {
    10.     public static void main(String[] args) throws Exception {
    11.         //往文件中写对象
    12. //        writeObject2File();
    13.         //从文件中读取对象
    14.         Singleton s1 = readObjectFromFile();
    15.         Singleton s2 = readObjectFromFile();
    16.  
    17.         //判断两个反序列化后的对象是否是同一个对象
    18.         System.out.println(s1 == s2);//false
    19.     }
    20.  
    21.     /**
    22.      * 从文件中读数据
    23.      * @return
    24.      * @throws Exception
    25.      */
    26.     private static Singleton readObjectFromFile() throws Exception {
    27.         //1.创建对象输入流对象
    28.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("a.txt"));
    29.         //2.第一个读取Singleton对象
    30.         Singleton instance = (Singleton) ois.readObject();
    31.         //3.释放资源
    32.         ois.close();
    33.         //4.返回结果
    34.         return instance;
    35.     }
    36.  
    37.     /**
    38.      * 向文件中写数据
    39.      * @throws Exception
    40.      */
    41.     public static void writeObject2File() throws Exception {
    42.         //1.获取Singleton类的对象
    43.         Singleton instance = Singleton.getInstance();
    44.         //2.创建对象输出流
    45.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("a.txt"));
    46.         //3.将instance对象写出到文件中
    47.         oos.writeObject(instance);
    48.         //4.释放资源
    49.         oos.close();
    50.     }
    51. }

    4.2反射破坏

    1. import java.io.Serializable;
    2.  
    3. /**
    4.  * 静态内部类方式
    5.  */
    6. public class Singleton implements Serializable{
    7.  
    8.     //私有构造方法
    9.     private Singleton() {
    10.     }
    11.  
    12.     //静态内部类
    13.     private static class SingletonHolder {
    14.         private static final Singleton INSTANCE = new Singleton();
    15.     }
    16.  
    17.     //对外提供静态方法获取该对象
    18.     public static Singleton getInstance() {
    19.         return SingletonHolder.INSTANCE;
    20.     }
    21. }
    1. import java.lang.reflect.Constructor;
    2.  
    3. /**
    4.  * 反射破坏单例模式
    5.  */
    6. public class Test {
    7.     public static void main(String[] args) throws Exception {
    8.         //获取Singleton类的字节码对象
    9.         Class c = Singleton.class;
    10.         //获取Singleton类的私有无参构造方法对象
    11.         Constructor constructor = c.getDeclaredConstructor();
    12.         //取消访问检查
    13.         constructor.setAccessible(true);
    14.  
    15.         //创建Singleton类的对象s1
    16.         Singleton s1 = (Singleton) constructor.newInstance();
    17.         //创建Singleton类的对象s2
    18.         Singleton s2 = (Singleton) constructor.newInstance();
    19.  
    20.         //判断通过反射创建的两个Singleton对象是否是同一个对象
    21.         System.out.println(s1 == s2);//false
    22.     }
    23. }

    5.解决单例模式破坏

    5.1解决序列化反序列化破坏

    1. import java.io.Serializable;
    2.  
    3. /**
    4.  * 静态内部类方式：解决序列化反序列化破解单例模式
    5.  */
    6. public class Singleton implements Serializable{
    7.  
    8.     //私有构造方法
    9.     private Singleton() {
    10.     }
    11.  
    12.     //静态内部类
    13.     private static class SingletonHolder {
    14.         private static final Singleton INSTANCE = new Singleton();
    15.     }
    16.  
    17.     //对外提供静态方法获取该对象
    18.     public static Singleton getInstance() {
    19.         return SingletonHolder.INSTANCE;
    20.     }
    21.  
    22.     /**
    23.      * 下面是为了解决序列化反序列化破解单例模式
    24.      * 当进行反序列化时，会自动调用该方法，将该方法的返回值直接返回
    25.      */
    26.     private Object readResolve() {
    27.         return SingletonHolder.INSTANCE;
    28.     }
    29. }

    5.2解决反射破坏

    1. /**
    2.  * 静态内部类方式：反射方式破解单例的解决方法
    3.  */
    4. public class Singleton {
    5.     private static boolean flag = false;
    6.  
    7.     //私有构造方法
    8.     private Singleton() {
    9.         if (flag) {//如果是true，不是第一次创建
    10.             throw new RuntimeException("不能创建多个对象");
    11.         }
    12.         flag = true;
    13.     }
    14.  
    15.     private static volatile Singleton instance;
    16.  
    17.     //对外提供静态方法获取该对象
    18.     public static Singleton getInstance() {
    19.  
    20.         if (instance != null) {
    21.             return instance;
    22.         }
    23.  
    24.         synchronized (Singleton.class) {
    25.             if (instance != null) {
    26.                 return instance;
    27.             }
    28.             instance = new Singleton();
    29.             return instance;
    30.         }
    31.     }
    32. }

    5.3还可以第二次用反射破坏

    1. import java.lang.reflect.Constructor;
    2. import java.lang.reflect.Field;
    3.  
    4. /**
    5.  * 第二次用反射破坏单例模式
    6.  */
    7. public class Test {
    8.     public static void main(String[] args) throws Exception {
    9.         //获取Singleton类的字节码对象
    10.         Class c = Singleton.class;
    11.         //获取Singleton类的私有无参构造方法对象
    12.         Constructor constructor = c.getDeclaredConstructor();
    13.         //取消访问检查
    14.         constructor.setAccessible(true);
    15.  
    16.         //创建Singleton类的对象s1
    17.         Singleton s1 = (Singleton) constructor.newInstance();
    18.  
    19.         //破坏单例
    20.         Field flag = c.getDeclaredField("flag");
    21.         flag.setAccessible(true);
    22.         flag.set(s1, false);
    23.  
    24.         //创建Singleton类的对象s2
    25.         Singleton s2 = (Singleton) constructor.newInstance();
    26.  
    27.         //判断通过反射创建的两个Singleton对象是否是同一个对象
    28.         System.out.println(s1 == s2);//false
    29.     }
    30. }

  • 相关阅读:
    学习笔记7--卫星定位技术(下)
    基于单片机的学生视力保护仪
    k8s部署针对外部服务器的prometheus服务
    js数据结构算法[栈操作]
    享元模式模式简介
    supervisor—进程管理神器
    Dubbo面试系列问题总结
    神经网络结构设计,神经网络架构设计
    【JVM】内存快照分析工具Jprofiler
    如何进行MDM的产品测试
  • 原文地址：https://blog.csdn.net/m0_63544124/article/details/125991056