单例模式

九天猎人  金牌会员 | 2023-5-31 20:41:36 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 873|帖子 873|积分 2619

单例模式（反射破坏-枚举）

饿汉式单例
  1. package com.jan.single;
  3. //饿汉式单例
  4. public class Hungry {
  5.     //一上来就会加载好，可能会浪费空间
  6.     private byte[] data11=new byte[1024*1024];
  7.     private byte[] data12=new byte[1024*1024];
  8.     private byte[] data13=new byte[1024*1024];
  9.     private byte[] data14=new byte[1024*1024];
  11.     private Hungry(){
  13.     }
  15.     private final static Hungry HUNGRY = new Hungry();//保证是唯一的了
  17.     public static Hungry getInstance(){ //一上来就加载了
  18.         return HUNGRY;
  19.     }
  20. }
复制代码
懒汉式单例
  1. package com.jan.single;
  3. //懒汉式单例
  4. public class LazyMan {
  6.     private LazyMan(){ ///构造器私有
  7.         System.out.println(Thread.currentThread().getName()+"ok");
  8.     }
  10.     private  static  LazyMan lazyMan;//对象
  12.     public static LazyMan getInstance(){
  13.         if(lazyMan==null){
  14.             lazyMan = new LazyMan();
  15.         }
  16.         return lazyMan;
  17.     }
  19.     //多线程并发
  20.     public static void main(String[] args){
  21.         for (int i = 0; i < 10; i++) {
  22.             new Thread(()->{
  23.                 LazyMan.getInstance();
  24.             }).start();
  25.         }
  26.     }
  27. }
复制代码
此时运行结果：单例有问题，偶尔会有多线程

静态内部类：
  1. package com.jan.single;
  3. //静态内部类
  4. public class Holder {
  6.     private Holder(){ //构造器私有
  8.     }
  10.     public static Holder getInstance(){
  11.         return InnerClass.HOLDER;
  12.     }
  14.     public static class InnerClass{
  15.         private static final Holder HOLDER = new Holder();
  16.     }
  17. }
复制代码
进阶-->加锁
  1. package com.jan.single;
  3. //懒汉式单例
  4. public class LazyMan {
  6.     private LazyMan(){ ///构造器私有
  7.         System.out.println(Thread.currentThread().getName()+"ok");
  8.     }
  10.     //为了安全，避免 lazyMan 指令重排，必须加volatile
  11.     private volatile static  LazyMan lazyMan;//对象
  13.     public static LazyMan getInstance(){  //这代码安全吗？
  14.         //双重检测锁模式的 懒汉式单例 DCL模式
  15.         if (lazyMan==null){
  16.             synchronized (LazyMan.class){  //保证这个类 LazyMan.class 只有一个
  17.                 if(lazyMan==null){
  18.                     lazyMan = new LazyMan(); //不是原子性操作
  19.                     /*
  20.                     * 1. 分配内存空间
  21.                     * 2. 执行构造方法，初始化对象
  22.                     * 3. 把这个对象指向这个空间
  23.                     *
  24.                     * 期望执行 123
  25.                     *          132 A(先占内存空间)
  26.                     * 若此时有 B线程  基于A，系统会认为 lazyMan 不为Null   直接return
  27.                     *        //此时lazyMan没有完成构造
  28.                     * */
  29.                 }
  30.             }
  31.         }
  32.         return lazyMan;
  33.     }
  35.     //多线程并发
  36.     public static void main(String[] args){
  37.         for (int i = 0; i < 10; i++) {
  38.             new Thread(()->{
  39.                 LazyMan.getInstance();
  40.             }).start();
  41.         }
  42.     }
  43. }
复制代码
单例不安全，反射

枚举

炫技时刻 ：反射破坏单例
  1. package com.jan.single;
  3. import java.lang.reflect.Constructor;
  5. //懒汉式单例
  6. public class LazyMan {
  8.     private LazyMan(){ ///构造器私有
  9.         System.out.println(Thread.currentThread().getName()+"ok");
  10.     }
  12.     //为了安全，避免 lazyMan 指令重排，必须加volatile
  13.     private volatile static  LazyMan lazyMan;//对象
  15.     public static LazyMan getInstance(){  //这代码安全吗？
  16.         //双重检测锁模式的 懒汉式单例 DCL模式
  17.         if (lazyMan==null){
  18.             synchronized (LazyMan.class){  //保证这个类 LazyMan.class 只有一个
  19.                 if(lazyMan==null){
  20.                     lazyMan = new LazyMan(); //不是原子性操作
  21.                  
  22.                 }
  24.             }
  26.         }
  27.         return lazyMan;
  28.     }
  30.     //反射
  31.     public static void main(String[] args) throws Exception {
  32.         LazyMan instance1 = LazyMan.getInstance();
  33.         Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);//获得空参构造器
  34.         declaredConstructor.setAccessible(true);//破坏私有权限，无视私有的构造器   通过反射来创建对象
  35.         LazyMan instance2= declaredConstructor.newInstance();
  37.         System.out.println(instance1);
  38.         System.out.println(instance2);
  39.     }
  40. }
复制代码
结果：

继续改进：不被反射破坏（三重检测）
  1. package com.jan.single;
  3. import java.lang.reflect.Constructor;
  5. //懒汉式单例
  6. public class LazyMan {
  8.     private LazyMan(){ ///构造器私有
  10.         synchronized (LazyMan.class){ //这里加一把锁，第二次用就会报错
  11.             if (lazyMan!=null){
  12.              throw new RuntimeException("不要试图使用反射破坏异常");
  13.             }
  14.         }
  15.     }
  17.     //为了安全，避免 lazyMan 指令重排，必须加volatile
  18.     private volatile static  LazyMan lazyMan;//对象
  20.     public static LazyMan getInstance(){  //这代码安全吗？
  21.         //双重检测锁模式的 懒汉式单例 DCL模式
  22.         if (lazyMan==null){
  23.             synchronized (LazyMan.class){  //保证这个类 LazyMan.class 只有一个
  24.                 if(lazyMan==null){
  25.                     lazyMan = new LazyMan(); //不是原子性操作
  26.                     /*
  27.                     * 1. 分配内存空间
  28.                     * 2. 执行构造方法，初始化对象
  29.                     * 3. 把这个对象指向这个空间
  30.                     *
  31.                     * 期望执行 123
  32.                     *          132 A(先占内存空间)
  33.                     * 若此时有 B线程  基于A，系统会认为 lazyMan 不为Null   直接return
  34.                     *        //此时lazyMan没有完成构造
  35.                     * */
  36.                 }
  38.             }
  40.         }
  41.         return lazyMan;
  42.     }
  44.    
  45.     //反射
  46.     public static void main(String[] args) throws Exception {
  47.         LazyMan instance1 = LazyMan.getInstance();
  48.         Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);//获得空参构造器
  49.         declaredConstructor.setAccessible(true);//破坏私有权限，无视私有的构造器   通过反射来创建对象
  50.         LazyMan instance2= declaredConstructor.newInstance();
  52.         System.out.println(instance1);
  53.         System.out.println(instance2);
  55.     }
  57. }
复制代码
结果：

继续破坏：

如果两个对象都是LazyMan instance2= declaredConstructor.newInstance();这样获得，单例又被破坏
解决：加密（jan）
  1. package com.jan.single;
  3. import java.lang.reflect.Constructor;
  5. //懒汉式单例
  6. public class LazyMan {
  8.     private static boolean jan = false;//定义一个变量
  11.     private LazyMan(){ ///构造器私有
  12.         synchronized (LazyMan.class){ //这里加一把锁，第二次用就会报错
  13.             if (jan==false){
  14.                 jan = true; //这个肯定会变
  15.             }else {
  16.                 throw new RuntimeException("不要试图使用反射破坏异常");
  17.             }
  19.         }
  20.     }
  22.     //为了安全，避免 lazyMan 指令重排，必须加volatile
  23.     private volatile static  LazyMan lazyMan;//对象
  25.     public static LazyMan getInstance(){  //这代码安全吗？
  26.         //双重检测锁模式的 懒汉式单例 DCL模式
  27.         if (lazyMan==null){
  28.             synchronized (LazyMan.class){  //保证这个类 LazyMan.class 只有一个
  29.                 if(lazyMan==null){
  30.                     lazyMan = new LazyMan(); //不是原子性操作
  31.                 }
  33.             }
  35.         }
  36.         return lazyMan;
  37.     }
  39.    
  40.     //反射
  41.     public static void main(String[] args) throws Exception {
  42.         //LazyMan instance1 = LazyMan.getInstance();
  43.         Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);//获得空参构造器
  44.         declaredConstructor.setAccessible(true);//破坏私有权限，无视私有的构造器  通过反射来创建对象
  45.         LazyMan instance2= declaredConstructor.newInstance();
  46.         LazyMan instance1= declaredConstructor.newInstance();
  48.         System.out.println(instance1);
  49.         System.out.println(instance2);
  51.     }
  53. }
复制代码
再破坏：

通过获取加密字段，从而破坏私有权限，再设置加密字段.instance = false
  1. package com.jan.single;
  3. import java.lang.reflect.Constructor;
  4. import java.lang.reflect.Field;
  6. //懒汉式单例
  7. //道高一尺魔高一丈
  8. public class LazyMan {
  10.     private static boolean jan = false;//定义一个变量
  13.     private LazyMan(){ ///构造器私有
  14.         synchronized (LazyMan.class){ //这里加一把锁，第二次用就会报错
  15.             if (jan==false){
  16.                 jan = true; //这个肯定会变
  17.             }else {
  18.                 throw new RuntimeException("不要试图使用反射破坏异常");
  19.             }
  21.         }
  22.     }
  24.     //为了安全，避免 lazyMan 指令重排，必须加volatile
  25.     private volatile static  LazyMan lazyMan;//对象
  27.     public static LazyMan getInstance(){  //这代码安全吗？
  28.         //双重检测锁模式的 懒汉式单例 DCL模式
  29.         if (lazyMan==null){
  30.             synchronized (LazyMan.class){  //保证这个类 LazyMan.class 只有一个
  31.                 if(lazyMan==null){
  32.                     lazyMan = new LazyMan(); //不是原子性操作
  33.                 }
  35.             }
  37.         }
  38.         return lazyMan;
  39.     }
  41.    
  42.     //反射
  43.     public static void main(String[] args) throws Exception {
  44.         //LazyMan instance1 =
  46.         Field jan = LazyMan.class.getDeclaredField("jan");//获取字段
  47.         jan.setAccessible(true);//破坏私有权限
  50.         Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);//获得空参构造器
  51.         declaredConstructor.setAccessible(true);//破坏私有权限，无视私有的构造器   通过反射来创建对象
  52.         LazyMan instance2= declaredConstructor.newInstance();
  54.         jan.set(instance2,false);
  55.         LazyMan instance1= declaredConstructor.newInstance();
  57.         System.out.println(instance1);
  58.         System.out.println(instance2);
  60.     }
  62. }
复制代码
结果：

万恶的反射怎么解决：枚举

反编译jad：https://varaneckas.com/jad/
  1. package com.jan.single;
  3. //枚举 是一个什么？ 本身也是class 类
  4. public enum EnumSingle {
  5.    
  6.     INSTANCE;//不可能被拿走
  7.    
  8.     public EnumSingle getInstance(){
  9.         return INSTANCE;
  10.     }
  11.    
  12. }
  14. class Test{  //先保证对象是唯一的，测试一下
  16.     public static void main(String[] args) {
  17.         EnumSingle instance1= EnumSingle.INSTANCE;
  18.         EnumSingle instance2= EnumSingle.INSTANCE;
  19.         System.out.println(instance1);
  20.         System.out.println(instance2);
  21.     }
  22. }
复制代码
结果：

看源码，有一个无参构造


在测试也使用无参构造
  1. package com.jan.single;
  2. import java.lang.reflect.Constructor;
  4. //枚举 是一个什么？ 本身也是class 类
  5. public enum EnumSingle {
  7.     INSTANCE;//不可能被拿走
  9.     public EnumSingle getInstance(){
  10.         return INSTANCE;
  11.     }
  12. }
  14. class Test{  //试一试能不能破坏,看源代码  有一个无参构造
  16.     public static void main(String[] args) throws Exception {
  17.         EnumSingle instance1= EnumSingle.INSTANCE; //有一个无参构造,试一试，看看是不是真的
  18.         Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);
  19.         declaredConstructor.setAccessible(true);
  20.         EnumSingle instance2 = declaredConstructor.newInstance();
  21.         //com.jan.single.EnumSingle.<init>()
  22.         //（newInstance 源码）正常报错是：throw new IllegalArgumentException("Cannot reflectively create enum objects");
  23.       
  24.         System.out.println(instance1);
  25.         System.out.println(instance2);
  27.     }
  28. }
复制代码
结果：被欺骗，这源码不是真的

因为newinstance的源码：

两个输出的结果不同！！！
反编译

在IDEA的targer中找到 EnumSingle.class，打开文件的文件的位置，再从文件的卫视输入 cmd
也有空参，也是骗我们的

更专业的反编译

jad

这里是有参构造

修改代码，这里只展示不同的
  1. Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
复制代码
结果：这个反射的确不能破坏枚举的单例

枚举最终反编译源码
  1. // Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
  2. // Jad home page: http://www.kpdus.com/jad.html
  3. // Decompiler options: packimports(3)
  4. // Source File Name:   EnumSingle.java
  6. package com.jan.single;
  9. public final class EnumSingle extends Enum
  10. {
  12.     public static EnumSingle[] values()
  13.     {
  14.         return (EnumSingle[])$VALUES.clone();
  15.     }
  17.     public static EnumSingle valueOf(String name)
  18.     {
  19.         return (EnumSingle)Enum.valueOf(com/jan/single/EnumSingle, name);
  20.     }
  22.     private EnumSingle(String s, int i)
  23.     {
  24.         super(s, i);
  25.     }
  27.     public EnumSingle getInstance()
  28.     {
  29.         return INSTANCE;
  30.     }
  32.     public static final EnumSingle INSTANCE;
  33.     private static final EnumSingle $VALUES[];
  35.     static
  36.     {
  37.         INSTANCE = new EnumSingle("INSTANCE", 0);
  38.         $VALUES = (new EnumSingle[] {
  39.             INSTANCE
  40.         });
  41.     }
  42. }
复制代码
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

九天猎人

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表