• java单例模式--懒汉式、饿汉式（第二次学习）

    目录

    java单例模式--懒汉式、饿汉式

    1、要点

    2、单例模式的类型（五种）

    2.1 饿汉式

    2.2 枚举饿汉式（推荐使用）

    2.3 懒汉式单例

    2.4 DCL懒汉式（双检锁的懒汉式）

    2.5 内部类懒汉式（推荐使用）

    3、jdk中的体现

    1、饿汉式的单例模式

    2、枚举饿汉式

    3、懒汉式的DCL（双检锁）

    4、内部类懒汉式

    java单例模式--懒汉式、饿汉式

    单例模式，属于创建类型的一种常用的软件设计模式。（23种设计模式之一）通过单例模式的方法创建的类在当前进程中只有一个实例

    1、要点

    • 构造器私有化

    • 定义静态变量存储这个对象唯一实例

    • 直接暴露或者封装使用getter方法提供实例的获取

    2、单例模式的类型（五种）

    饿汉式、枚举饿汉式、懒汉式、双锁懒汉式、内部类懒汉式 五种

    2.1 饿汉式

    饿汉式:即当类初始化的时候就创建实例对象 --就叫做饿汉式

    代码

    1. package com.sofwin.singletonDemo;
    2. ​
    3. /**
    4.  * @packageName: com.sofwin.singletonDemo
    5.  * @author: wentao
    6.  * @date: 2022/11/21 10:00
    7.  * @version: 1.0
    8.  * @email 1660420659@qq.com
    9.  * @description: 单例模式-饿汉式
    10.  *
    11.  * 要点：
    12.  *      1.构造器私有化
    13.  *      2.定义静态常量存储对象唯一实例
    14.  *      3.通过getter方法获取实例对象
    15.  */
    16. public class Singleton01 {
    17. ​
    18.     /**
    19.      * 构造器私有化
    20.      */
    21.     private static final Singleton01 SINGLETON_01 = new Singleton01();
    22. ​
    23. ​
    24.     private  Singleton01() {
    25.         System.out.println("private Singleton01");
    26.     }
    27. ​
    28.     public static Singleton01 getSingleton01() {
    29.         return SINGLETON_01;
    30.     }
    31. ​
    32.     /**
    33.      * 通过调用静态方法,实现类的初始化
    34.      * 判断实例对象是类初始化就创建了 还是调用获取实例对象的时候才进行创建
    35.      */
    36.     public static void otherMethod() {
    37.         System.out.println("判断是懒汉式还是饿汉式");
    38.     }
    39. }
    ​

    测试

    1. package com.sofwin.singletonDemo;
    2. ​
    3. import org.junit.Test;
    4. ​
    5. /**
    6.  * @packageName: com.sofwin.singletonDemo
    7.  * @author: wentao
    8.  * @date: 2022/11/21 10:09
    9.  * @version: 1.0
    10.  * @email 1660420659@qq.com
    11.  * @description: 单例模式的测试
    12.  */
    13. public class SingletonTest {
    14. ​
    15.     //单例模式-饿汉式
    16.     @Test
    17.     public void SinletonTest01() {
    18.         //先判断是否类初始化的时候就创建对象了
    19.         Singleton01.otherMethod();
    20.         System.out.println("=================");
    21.         Singleton01 singleton01 = Singleton01.getSingleton01();
    22.         Singleton01 singleton02 = Singleton01.getSingleton01();
    23.         System.out.println(singleton01);
    24.         System.out.println(singleton02);
    25.     }
    26. }

    （类加载就创建实例---饿汉式） 

    这种设计有三种方法可以进行破坏

    1、反射破坏单例

    1. package com.sofwin.singletonDemo;
    2. ​
    3. import org.junit.Test;
    4. ​
    5. import java.lang.reflect.Constructor;
    6. import java.lang.reflect.InvocationTargetException;
    7. ​
    8. /**
    9.  * @packageName: com.sofwin.singletonDemo
    10.  * @author: wentao
    11.  * @date: 2022/11/21 10:09
    12.  * @version: 1.0
    13.  * @email 1660420659@qq.com
    14.  * @description: 单例模式的测试
    15.  */
    16. public class SingletonTest {
    17. ​
    18.     //单例模式-饿汉式
    19.     @Test
    20.     public void SinletonTest01() throws InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
    21.         //先判断是否类初始化的时候就创建对象了
    22.         Singleton01.otherMethod();
    23.         System.out.println("=================");
    24.         Singleton01 singleton01 = Singleton01.getSingleton01();
    25.         Singleton01 singleton02 = Singleton01.getSingleton01();
    26.         System.out.println(singleton01);
    27.         System.out.println(singleton02);
    28.         System.out.println("暴力破解");
    29.         SingletonTest.reflection(Singleton01.class);
    30.     }
    31. ​
    32.     /**
    33.      * 反射破坏单例pos
    34.      * @param clazz  类对象
    35.      */
    36.     public static void reflection(Class clazz) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    37.         //获取无参构造方法
    38.         Constructor declaredConstructor = clazz.getDeclaredConstructor();
    39.         //暴力破解
    40.         declaredConstructor.setAccessible(true);
    41.         //通过反射创建实例对象
    42.         Object o = declaredConstructor.newInstance();
    43.         System.out.println(o);
    44.     }
    45. }
    ​
通过反射暴力破解，得到新的实例对象 

    改进

    1. package com.sofwin.singletonDemo;
    2. ​
    3. /**
    4.  * @packageName: com.sofwin.singletonDemo
    5.  * @author: wentao
    6.  * @date: 2022/11/21 10:00
    7.  * @version: 1.0
    8.  * @email 1660420659@qq.com
    9.  * @description: 单例模式-饿汉式
    10.  *
    11.  * 要点：
    12.  *      1.构造器私有化
    13.  *      2.定义静态常量存储对象唯一实例
    14.  *      3.通过getter方法获取实例对象
    15.  */
    16. public class Singleton01 {
    17. ​
    18.     /**
    19.      * 构造器私有化
    20.      */
    21.     private static final Singleton01 SINGLETON_01 = new Singleton01();
    22. ​
    23. ​
    24.     private  Singleton01() {
    25.         //防止反射破坏单例
    26.         if (SINGLETON_01 !=null) {
    27.           throw new RuntimeException("单例对象不能重复创建");
    28.         }
    29.         System.out.println("private Singleton01");
    30.     }
    31. ​
    32.     public static Singleton01 getSingleton01() {
    33.         return SINGLETON_01;
    34.     }
    35. ​
    36.     /**
    37.      * 通过调用静态方法,实现类的初始化
    38.      * 判断实例对象是类初始化就创建了 还是调用获取实例对象的时候才进行创建
    39.      */
    40.     public static void otherMethod() {
    41.         System.out.println("判断是懒汉式还是饿汉式");
    42.     }
    43. }
     

    2、反序列化破坏单例

    Singleton01类要实现Serializable

    1. package com.sofwin.singletonDemo;
    2. ​
    3. import java.io.Serializable;
    4. ​
    5. /**
    6.  * @packageName: com.sofwin.singletonDemo
    7.  * @author: wentao
    8.  * @date: 2022/11/21 10:00
    9.  * @version: 1.0
    10.  * @email 1660420659@qq.com
    11.  * @description: 单例模式-饿汉式
    12.  *
    13.  * 要点：
    14.  *      1.构造器私有化
    15.  *      2.定义静态常量存储对象唯一实例
    16.  *      3.通过getter方法获取实例对象
    17.  */
    18. public class Singleton01 implements Serializable {
    19. ​
    20.     /**
    21.      * 构造器私有化
    22.      */
    23.     private static final Singleton01 SINGLETON_01 = new Singleton01();
    24. ​
    25. ​
    26.     private  Singleton01() {
    27.         //防止反射破坏单例
    28.         if (SINGLETON_01 !=null) {
    29.           throw new RuntimeException("单例对象不能重复创建");
    30.         }
    31.         System.out.println("private Singleton01");
    32.     }
    33. ​
    34.     public static Singleton01 getSingleton01() {
    35.         return SINGLETON_01;
    36.     }
    37. ​
    38.     /**
    39.      * 通过调用静态方法,实现类的初始化
    40.      * 判断实例对象是类初始化就创建了 还是调用获取实例对象的时候才进行创建
    41.      */
    42.     public static void otherMethod() {
    43.         System.out.println("判断是懒汉式还是饿汉式");
    44.     }
    45. }

    测试代码

    1. package com.sofwin.singletonDemo;
    2. ​
    3. import org.junit.Test;
    4. ​
    5. import java.io.*;
    6. import java.lang.reflect.Constructor;
    7. import java.lang.reflect.InvocationTargetException;
    8. ​
    9. /**
    10.  * @packageName: com.sofwin.singletonDemo
    11.  * @author: wentao
    12.  * @date: 2022/11/21 10:09
    13.  * @version: 1.0
    14.  * @email 1660420659@qq.com
    15.  * @description: 单例模式的测试
    16.  */
    17. public class SingletonTest {
    18. ​
    19.     //单例模式-饿汉式
    20.     @Test
    21.     public void SinletonTest01() throws InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException, IOException, ClassNotFoundException {
    22.         //先判断是否类初始化的时候就创建对象了
    23.         Singleton01.otherMethod();
    24.         System.out.println("=================");
    25.         Singleton01 singleton01 = Singleton01.getSingleton01();
    26.         Singleton01 singleton02 = Singleton01.getSingleton01();
    27.         System.out.println(singleton01);
    28.         System.out.println(singleton02);
    29. //        System.out.println("反射暴力破解");
    30. //        SingletonTest.reflection(Singleton01.class);
    31.         System.out.println("反序列化破解");
    32.         SingletonTest.serialzable(singleton02);
    33.     }
    34. ​
    35.     /**
    36.      * 反射破坏单例pos
    37.      * @param clazz  类对象
    38.      */
    39.     public static void reflection(Class clazz) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    40.         //获取无参构造方法
    41.         Constructor declaredConstructor = clazz.getDeclaredConstructor();
    42.         //暴力破解
    43.         declaredConstructor.setAccessible(true);
    44.         //通过反射创建实例对象
    45.         Object o = declaredConstructor.newInstance();
    46.         System.out.println(o);
    47.     }
    48. ​
    49.     /**
    50.      * 反序列破解单例模式
    51.      * @param instance 对象
    52.      */
    53.     public static void serialzable(Object instance) throws IOException, ClassNotFoundException {
    54.         //将对象读取到baos中
    55.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
    56.         ObjectOutputStream oos = new ObjectOutputStream(baos);
    57.         oos.writeObject(instance);
    58.         //通过字节数组获取对象
    59.         ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()));
    60.         Object o = ois.readObject();
    61.         System.out.println(o);
    62.     }
    63. }

    改进

    1. package com.sofwin.singletonDemo;
    2. ​
    3. import java.io.Serializable;
    4. ​
    5. /**
    6.  * @packageName: com.sofwin.singletonDemo
    7.  * @author: wentao
    8.  * @date: 2022/11/21 10:00
    9.  * @version: 1.0
    10.  * @email 1660420659@qq.com
    11.  * @description: 单例模式-饿汉式
    12.  *
    13.  * 要点：
    14.  *      1.构造器私有化
    15.  *      2.定义静态常量存储对象唯一实例
    16.  *      3.通过getter方法获取实例对象
    17.  */
    18. public class Singleton01 implements Serializable {
    19. ​
    20.     /**
    21.      * 构造器私有化
    22.      */
    23.     private static final Singleton01 SINGLETON_01 = new Singleton01();
    24. ​
    25. ​
    26.     private  Singleton01() {
    27.         //防止反射破坏单例
    28.         if (SINGLETON_01 !=null) {
    29.           throw new RuntimeException("单例对象不能重复创建");
    30.         }
    31.         System.out.println("private Singleton01");
    32.     }
    33. ​
    34.     public static Singleton01 getSingleton01() {
    35.         return SINGLETON_01;
    36.     }
    37. ​
    38.     /**
    39.      * 通过调用静态方法,实现类的初始化
    40.      * 判断实例对象是类初始化就创建了 还是调用获取实例对象的时候才进行创建
    41.      */
    42.     public static void otherMethod() {
    43.         System.out.println("判断是懒汉式还是饿汉式");
    44.     }
    45. ​
    46.     /**
    47.      * 解决反序列化
    48.      * @return  实例对象
    49.      * 
    50.      */
    51.     public Object readResolve() {
    52.         return SINGLETON_01;
    53.     }
    54. ​
    55. ​
    56. }
    ​ 

    这里 readResolve() 方法的解释

    简而言之，当我们通过反序列化readObejct方法获取对象的时候，会去寻找readResolve()方法，如果该方法不存在则直接返回新对象，如果该方法存在则按照该方法的内容返回对象，以确保如果我们之前实例化了单例对象，就返回该对象。

    为什么要使用功能readResolve（）方法就解决了？

      

    这里看一下重点代码，readOrdinaryObject方法的代码片段：

    isInstantiable：如果一个serializable/externalizable的类可以在运行时被实例化，那么该方法就返回true。针对serializable和externalizable我会在其他文章中介绍。

    desc.newInstance：该方法通过反射的方式调用无参构造方法新建一个对象。

    然后关键是下面的代码

    1. if (obj != null &&
    2.     handles.lookupException(passHandle) == null &&
    3.     desc.hasReadResolveMethod())
    4. {
    5.     Object rep = desc.invokeReadResolve(obj);
    6.     if (unshared && rep.getClass().isArray()) {
    7.         rep = cloneArray(rep);
    8.     }
    9.     if (rep != obj) {
    10.         // Filter the replacement object
    11.         if (rep != null) {
    12.             if (rep.getClass().isArray()) {
    13.                 filterCheck(rep.getClass(), Array.getLength(rep));
    14.             } else {
    15.                 filterCheck(rep.getClass(), -1);
    16.             }
    17.         }
    18.         handles.setObject(passHandle, obj = rep);
    19.     }
    20. }

    hasReadResolveMethod:如果实现了serializable 或者 externalizable接口的类中包含readResolve则返回true

    invokeReadResolve:通过反射的方式调用要被反序列化的类的readResolve方法。

    所以，原理也就清楚了，主要在Singleton中定义readResolve方法，并在该方法中指定要返回的对象的生成策略，就可以防止单例被破坏。

    3、Unsafe破坏单例

    1. package com.sofwin.singletonDemo;
    2. ​
    3. import org.junit.Test;
    4. import org.springframework.objenesis.instantiator.util.UnsafeUtils;
    5. ​
    6. import java.io.*;
    7. import java.lang.reflect.Constructor;
    8. import java.lang.reflect.InvocationTargetException;
    9. ​
    10. /**
    11.  * @packageName: com.sofwin.singletonDemo
    12.  * @author: wentao
    13.  * @date: 2022/11/21 10:09
    14.  * @version: 1.0
    15.  * @email 1660420659@qq.com
    16.  * @description: 单例模式的测试
    17.  */
    18. public class SingletonTest {
    19. ​
    20.     //单例模式-饿汉式
    21.     @Test
    22.     public void SinletonTest01() throws InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException, IOException, ClassNotFoundException {
    23.         //先判断是否类初始化的时候就创建对象了
    24.         Singleton01.otherMethod();
    25.         System.out.println("=================");
    26.         Singleton01 singleton01 = Singleton01.getSingleton01();
    27.         Singleton01 singleton02 = Singleton01.getSingleton01();
    28.         System.out.println(singleton01);
    29.         System.out.println(singleton02);
    30. //        System.out.println("反射暴力破解");
    31. //        SingletonTest.reflection(Singleton01.class);
    32. //        System.out.println("反序列化破解");
    33. //        SingletonTest.serialzable(singleton02);
    34.         System.out.println("unsafe");
    35.         unsafe(singleton01.getClass());
    36.     }
    37. ​
    38.     /**
    39.      * 反射破坏单例pos
    40.      * @param clazz  类对象
    41.      */
    42.     public static void reflection(Class clazz) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    43.         //获取无参构造方法
    44.         Constructor declaredConstructor = clazz.getDeclaredConstructor();
    45.         //暴力破解
    46.         declaredConstructor.setAccessible(true);
    47.         //通过反射创建实例对象
    48.         Object o = declaredConstructor.newInstance();
    49.         System.out.println(o);
    50.     }
    51. ​
    52.     /**
    53.      * 反序列破解单例模式
    54.      * @param instance 对象
    55.      */
    56.     public static void serialzable(Object instance) throws IOException, ClassNotFoundException {
    57.         //将对象读取到baos中
    58.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
    59.         ObjectOutputStream oos = new ObjectOutputStream(baos);
    60.         oos.writeObject(instance);
    61.         //通过字节数组获取对象
    62.         ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()));
    63.         Object o = ois.readObject();
    64.         System.out.println(o);
    65.     }
    66. ​
    67.     /**
    68.      * 使用spring的工具类在jdk底层来访问，无序调用构造方法
    69.      * @param clazz
    70.      * @throws InstantiationException
    71.      */
    72.     public static void unsafe(Class clazz) throws InstantiationException {
    73.         Object o = UnsafeUtils.getUnsafe().allocateInstance(clazz);
    74.         System.out.println(o);
    75.     }
    76. }

    这个是无法解决的

    2.2 枚举饿汉式（推荐使用）

    代码

    1. package com.sofwin.singletonDemo;
    2. ​
    3. import sun.dc.pr.PRError;
    4. ​
    5. /**
    6.  * @packageName: com.sofwin.singletonDemo
    7.  * @author: wentao
    8.  * @date: 2022/11/21 11:34
    9.  * @version: 1.0
    10.  * @email 1660420659@qq.com
    11.  * @description: 单例模式 --枚举饿汉式
    12.  */
    13. public enum Singleton02 {
    14.      INSTANCE;
    15. ​
    16.      private Singleton02() {
    17.          System.out.println("private Singleton02");
    18.      }
    19. ​
    20.      public static Singleton02 getInstance() {
    21.          return  INSTANCE;
    22.      }
    23. ​
    24.     /**
    25.      * 通过调用静态方法,实现类的初始化
    26.      * 判断实例对象是类初始化就创建了 还是调用获取实例对象的时候才进行创建
    27.      */
    28.     public static void otherMethod() {
    29.         System.out.println("判断是懒汉式还是饿汉式");
    30.     }
    31. ​
    32.     @Override
    33.     public String toString() {
    34.         //Integer.toHexString 转换为16进制
    35.         return getClass().getName()+"@"+Integer.toHexString(hashCode());
    36.     }
    37. }

    测试

    1. package com.sofwin.singletonDemo;
    2. ​
    3. import org.junit.Test;
    4. import org.springframework.objenesis.instantiator.util.UnsafeUtils;
    5. ​
    6. import java.io.*;
    7. import java.lang.reflect.Constructor;
    8. import java.lang.reflect.InvocationTargetException;
    9. ​
    10. /**
    11.  * @packageName: com.sofwin.singletonDemo
    12.  * @author: wentao
    13.  * @date: 2022/11/21 10:09
    14.  * @version: 1.0
    15.  * @email 1660420659@qq.com
    16.  * @description: 单例模式的测试
    17.  */
    18. public class SingletonTest {
    19. ​
    20.     //单例模式-饿汉式
    21.     @Test
    22.     public void SinletonTest01() throws InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException, IOException, ClassNotFoundException {
    23.         //先判断是否类初始化的时候就创建对象了
    24.         Singleton01.otherMethod();
    25.         System.out.println("=================");
    26.         Singleton02 singleton01 = Singleton02.INSTANCE;
    27.         Singleton02 singleton02 = Singleton02.INSTANCE;
    28.         System.out.println(singleton01);
    29.         System.out.println(singleton02);
    30.         //1、反射不存在，枚举没有无参构造器
    31. //        System.out.println("反射暴力破解");
    32. //        SingletonTest.reflection(Singleton02.class);
    33.         //2、反序列化不存在，readObject的时候会进行判断 ，如果是枚举类有特殊处理
    34. //        System.out.println("反序列化破解");
    35. //        SingletonTest.serialzable(singleton02);
    36.         //3、jdk这个是无法避免的，是可以破坏的
    37. //        System.out.println("unsafe");
    38. //        unsafe(singleton01.getClass());
    39.     }
    40. ​
    41.     /**
    42.      * 反射破坏单例pos
    43.      * @param clazz  类对象
    44.      */
    45.     public static void reflection(Class clazz) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    46.         //获取无参构造方法
    47.         Constructor declaredConstructor = clazz.getDeclaredConstructor();
    48.         //暴力破解
    49.         declaredConstructor.setAccessible(true);
    50.         //通过反射创建实例对象
    51.         Object o = declaredConstructor.newInstance();
    52.         System.out.println(o);
    53.     }
    54. ​
    55.     /**
    56.      * 反序列破解单例模式
    57.      * @param instance 对象
    58.      */
    59.     public static void serialzable(Object instance) throws IOException, ClassNotFoundException {
    60.         //将对象读取到baos中
    61.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
    62.         ObjectOutputStream oos = new ObjectOutputStream(baos);
    63.         oos.writeObject(instance);
    64.         //通过字节数组获取对象
    65.         ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()));
    66.         Object o = ois.readObject();
    67.         System.out.println(o);
    68.     }
    69. ​
    70.     /**
    71.      * 使用spring的工具类在jdk底层来访问，无序调用构造方法
    72.      * @param clazz
    73.      * @throws InstantiationException
    74.      */
    75.     public static void unsafe(Class clazz) throws InstantiationException {
    76.         Object o = UnsafeUtils.getUnsafe().allocateInstance(clazz);
    77.         System.out.println(o);
    78.     }
    79. }

    1、反射无法破坏枚举类单例

    枚举没有无参构造

    修改成有参构造

    1. /**
    2.  * 反射破坏单例pos
    3.  * @param clazz  类对象
    4.  */
    5. public static void reflection(Class clazz) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    6.     //获取无参构造方法
    7.     Constructor declaredConstructor = clazz.getDeclaredConstructor(String.class,int.class);
    8.     //暴力破解
    9.     declaredConstructor.setAccessible(true);
    10.     //通过反射创建实例对象
    11.     Object o = declaredConstructor.newInstance("OTHER",1);
    12.     System.out.println(o);
    13. }

    2、反序列话也无法破坏枚举类的单例

     3、Unsafe是可以破坏的

    2.3 懒汉式单例

    代码

    1. package com.sofwin.singletonDemo;
    2. ​
    3. import java.io.Serializable;
    4. ​
    5. /**
    6.  * @packageName: com.sofwin.singletonDemo
    7.  * @author: wentao
    8.  * @date: 2022/11/21 10:00
    9.  * @version: 1.0
    10.  * @email 1660420659@qq.com
    11.  * @description: 单例模式-懒汉式
    12.  *
    13.  * 要点：
    14.  *      1.构造器私有化
    15.  *      2.定义静态常量存储对象唯一实例
    16.  *      3.通过getter方法获取实例对象
    17.  */
    18. public class Singleton03 implements Serializable {
    19. ​
    20.     /**
    21.      * 构造器私有化
    22.      */
    23.     private static  Singleton03 instance = null;
    24. ​
    25. ​
    26.     private Singleton03() {
    27.         //防止反射破坏单例
    28.         if (instance !=null) {
    29.           throw new RuntimeException("单例对象不能重复创建");
    30.         }
    31.         System.out.println("private Singleton01");
    32.     }
    33. ​
    34.     public static Singleton03 getSingleton01() {
    35.         if (instance == null) {
    36.             instance = new Singleton03();
    37.         }
    38.         return instance;
    39.     }
    40. ​
    41.     /**
    42.      * 通过调用静态方法,实现类的初始化
    43.      * 判断实例对象是类初始化就创建了 还是调用获取实例对象的时候才进行创建
    44.      */
    45.     public static void otherMethod() {
    46.         System.out.println("判断是懒汉式还是饿汉式");
    47.     }
    48. ​
    49.     /**
    50.      * 解决反序列化
    51.      * @return  实例对象
    52.      *
    53.      */
    54.     public Object readResolve() {
    55.         return instance;
    56.     }
    57. ​
    58. ​
    59. }

    测试

    1. package com.sofwin.singletonDemo;
    2. ​
    3. import org.junit.Test;
    4. import org.springframework.objenesis.instantiator.util.UnsafeUtils;
    5. ​
    6. import java.io.*;
    7. import java.lang.reflect.Constructor;
    8. import java.lang.reflect.InvocationTargetException;
    9. ​
    10. /**
    11.  * @packageName: com.sofwin.singletonDemo
    12.  * @author: wentao
    13.  * @date: 2022/11/21 10:09
    14.  * @version: 1.0
    15.  * @email 1660420659@qq.com
    16.  * @description: 单例模式的测试
    17.  */
    18. public class SingletonTest {
    19. ​
    20.     //单例模式-饿汉式
    21.     @Test
    22.     public void SinletonTest01() throws InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException, IOException, ClassNotFoundException {
    23.         //先判断是否类初始化的时候就创建对象了
    24.         Singleton03.otherMethod();
    25.         System.out.println("=================");
    26.         Singleton03 singleton01 = Singleton03.getSingleton01();
    27.         Singleton03 singleton02 = Singleton03.getSingleton01();
    28.         System.out.println(singleton01);
    29.         System.out.println(singleton02);
    30.         //1、反射可以破坏单例
    31. //        System.out.println("反射暴力破解");
    32. //        SingletonTest.reflection(Singleton03.class);
    33.         //2、反序列化也可以破坏
    34. //        System.out.println("反序列化破解");
    35. //        SingletonTest.serialzable(singleton02);
    36.         //3、jdk这个是无法避免的，是可以破坏的
    37. //        System.out.println("unsafe");
    38. //        unsafe(singleton01.getClass());
    39.     }
    40. ​
    41.     /**
    42.      * 反射破坏单例pos
    43.      * @param clazz  类对象
    44.      */
    45.     public static void reflection(Class clazz) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    46.         //获取无参构造方法
    47.         Constructor declaredConstructor = clazz.getDeclaredConstructor();
    48.         //暴力破解
    49.         declaredConstructor.setAccessible(true);
    50.         //通过反射创建实例对象
    51.         Object o = declaredConstructor.newInstance();
    52.         System.out.println(o);
    53.     }
    54. ​
    55.     /**
    56.      * 反序列破解单例模式
    57.      * @param instance 对象
    58.      */
    59.     public static void serialzable(Object instance) throws IOException, ClassNotFoundException {
    60.         //将对象读取到baos中
    61.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
    62.         ObjectOutputStream oos = new ObjectOutputStream(baos);
    63.         oos.writeObject(instance);
    64.         //通过字节数组获取对象
    65.         ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()));
    66.         Object o = ois.readObject();
    67.         System.out.println(o);
    68.     }
    69. ​
    70.     /**
    71.      * 使用spring的工具类在jdk底层来访问，无序调用构造方法
    72.      * @param clazz
    73.      * @throws InstantiationException
    74.      */
    75.     public static void unsafe(Class clazz) throws InstantiationException {
    76.         Object o = UnsafeUtils.getUnsafe().allocateInstance(clazz);
    77.         System.out.println(o);
    78.     }
    79. }

    反射、序列化和unsafe都可以破坏

    但是这样都会导致一个问题多线程的情况会出现错误情况 （之前，懒汉式的常量和静态代码块中的代码，其实是jvm底层维护的是线程安全的，无序考虑） 因为这个是方法中创建实例就会出现线程安全的问题

    测试代码

    1. public class SingletonTest {
    2. ​
    3.     public static void main(String[]args){
    4.        new Thread( new Runnable() {
    5.             @Override
    6.             public void run() {
    7.                 Singleton03 singleton01 = Singleton03.getSingleton01();
    8.                 System.out.println(singleton01);
    9.             }
    10.         }).start();
    11. ​
    12.         new Thread( new Runnable() {
    13.             @Override
    14.             public void run() {
    15.                 Singleton03 singleton01 = Singleton03.getSingleton01();
    16.                 System.out.println(singleton01);
    17.             }
    18.         }).start();
    19.     }
    20.   }

    正常应该是这种情况：

     但是多运行几次，也会出现这样的情况：

     造成的这种情况的结果是问题是：

    这个时候就出现了DCL懒汉式（双检锁的懒汉式）

    2.4 DCL懒汉式（双检锁的懒汉式）

    1. package com.sofwin.singletonDemo;
    2. ​
    3. import java.io.Serializable;
    4. ​
    5. /**
    6.  * @packageName: com.sofwin.singletonDemo
    7.  * @author: wentao
    8.  * @date: 2022/11/21 10:00
    9.  * @version: 1.0
    10.  * @email 1660420659@qq.com
    11.  * @description: 单例模式-懒汉式
    12.  *
    13.  * 要点：
    14.  *      1.构造器私有化
    15.  *      2.定义静态常量存储对象唯一实例
    16.  *      3.通过getter方法获取实例对象
    17.  */
    18. public class Singleton04 implements Serializable {
    19. ​
    20.     /**
    21.      * 构造器私有化
    22.      */
    23.     //这里加入valatile是保证这个变量是有序的，可见的
    24.     //防止指令重排序，在赋值语句后加入一个内存屏障，防止之前的赋值操作，进行重新排序
    25.     private static volatile Singleton04 instance = null;
    26. ​
    27. ​
    28. ​
    29.     private Singleton04() {
    30.         //防止反射破坏单例
    31.         if (instance !=null) {
    32.           throw new RuntimeException("单例对象不能重复创建");
    33.         }
    34.         System.out.println("private Singleton01");
    35.     }
    36. ​
    37.     public static Singleton04 getSingleton01() {
    38.         
    39.         if (instance == null) {
    40.             synchronized (Singleton04.class){
    41.                 if (instance == null) {
    42.                     instance = new Singleton04();
    43.                 }
    44.             }
    45.         }
    46.         return instance;
    47.     }
    48. ​
    49.     /**
    50.      * 通过调用静态方法,实现类的初始化
    51.      * 判断实例对象是类初始化就创建了 还是调用获取实例对象的时候才进行创建
    52.      */
    53.     public static void otherMethod() {
    54.         System.out.println("判断是懒汉式还是饿汉式");
    55.     }
    56. ​
    57.     /**
    58.      * 解决反序列化
    59.      * @return  实例对象
    60.      *
    61.      */
    62.     public Object readResolve() {
    63.         return instance;
    64.     }
    65. ​
    66. ​
    67. }

    这个代码可以这样理解：

    public static Singleton04 getSingleton01() {

         if (instance == null) {

    synchronized (Singleton04.class){

            if (instance == null) {

                      instance = new Singleton04();

              }

    }

    //里面这一块是进行加锁放在出现上面的情况

    //外面的if判断是进行代码的优化

    //我们这个线程锁只是还没创建对象实例的情况出现，因此加上if后

    //我们就保证了后序的调用无需进行加锁操作，加快了效率

         }

    return instance;

    }

    2.5 内部类懒汉式（推荐使用）

    1. package com.sofwin.singletonDemo;
    2. ​
    3. import java.io.Serializable;
    4. ​
    5. /**
    6.  * @packageName: com.sofwin.singletonDemo
    7.  * @author: wentao
    8.  * @date: 2022/11/21 10:00
    9.  * @version: 1.0
    10.  * @email 1660420659@qq.com
    11.  * @description: 单例模式-内部类懒汉式
    12.  *
    13.  * 要点：
    14.  *      内部类不会随着玩不类的加载而初始化
    15.  *      它是单独进行初始化和加载的，并且静态成员的赋值，都是在静态代码块中的，是底层保证线程安全的
    16.  *      只有调用内部类的类变量的时候，才进行初始化，实现懒汉式模式
    17.  */
    18. public class Singleton05 implements Serializable {
    19. ​
    20.     /**
    21.      * 构造器私有化
    22.      */
    23.     private Singleton05() {
    24.         System.out.println("private Singleton01");
    25.     }
    26. ​
    27.     private static class Holder {
    28.         static  Singleton05 instance = new Singleton05();
    29.     }
    30. ​
    31.     public static Singleton05 getSingleton01() {
    32.         return Holder.instance;
    33.     }
    34. ​
    35.     /**
    36.      * 通过调用静态方法,实现类的初始化
    37.      * 判断实例对象是类初始化就创建了 还是调用获取实例对象的时候才进行创建
    38.      */
    39.     public static void otherMethod() {
    40.         System.out.println("判断是懒汉式还是饿汉式");
    41.     }
    42. ​
    43. ​
    44. ​
    45. ​
    46. }

    3、jdk中的体现

    1、饿汉式的单例模式

    System的gc() 垃圾回收机制中的Runtime.getRuntime().gc()

    1. public class Runtime {
    2.     private static Runtime currentRuntime = new Runtime();
    3. ​
    4.     /**
    5.      * Returns the runtime object associated with the current Java application.
    6.      * Most of the methods of class Runtime are instance
    7.      * methods and must be invoked with respect to the current runtime object.
    8.      *
    9.      * @return  the Runtime object associated with the current
    10.      *          Java application.
    11.      */
    12.     public static Runtime getRuntime() {
    13.         return currentRuntime;
    14.     }
    15. ​
    16.     /** Don't let anyone else instantiate this class */
    17.     private Runtime() {}

    2、枚举饿汉式

    Comparator的naturalOrder()

    3、懒汉式的DCL（双检锁）

    System中的cons成员变量

    4、内部类懒汉式

    Collections中的emptyListInterator() 

  • 相关阅读:
    sql注入(5), sqlmap工具
    JVM虚拟机：通过日志学习PS+PO垃圾回收器
    C++指针解读（8） -- 指针数组和二重指针
    基于遗传算法的红绿灯间隔时间优化（代码完整，数据齐全）
    如何使用grafana 下JSON API访问展示接口数据
    《uni-app》一个非canvas的飞机对战小游戏实现-子弹模型的实现
    汉诺塔问题（java）
    2023.9.23 关于 HTTP 详解
    服务器简单介绍
    结构光三维重建（一）条纹结构光三维重建
  • 原文地址：https://blog.csdn.net/weixin_52574640/article/details/127972850