单例模式

只要是单例模式，构造器一定私有化，即用private修饰。

一.饿汉式单例

1. package single;
3. /*
4.     饿汉式单例
5. */
6. public class Hungry {
8.     //可能会浪费空间
9.     private byte[] data1 = new byte[1024*1024];
10.     private byte[] data2 = new byte[1024*1024];
11.     private byte[] data3 = new byte[1024*1024];
12.     private byte[] data4 = new byte[1024*1024];
14.     //构造器私有
15.     private Hungry() {}
17.     //实例化私有并且用final修饰
18.     private final static Hungry HUNGRY = new Hungry();
20.     public static Hungry getInstance(){
21.         return HUNGRY;
22.     }
23. }

复制代码

二.懒汉式单例

1. package single;
3. import java.lang.reflect.Constructor;
4. import java.lang.reflect.Field;
6. //懒汉式单例
7. public class LazyMan {
9.     //红绿灯标志位，不让反射获取对象,反射通过构造器来获取对象
10.     private static boolean blog = false;
12.     //构造器私有
13.     private LazyMan() {
14.         synchronized (LazyMan.class) {
15.             if (blog == false) {
16.                 blog = true;
17.             }else {
18.                 throw new RuntimeException("不要试图破坏单例");
19.             }
20.         }
21.     }
23.     //实例化私有
24.     private volatile static LazyMan lazyMan;
26.     //双重检验锁模式 懒汉式单例 简称DCL懒汉式
27.     public static LazyMan getInstance() {
28.         if (lazyMan == null) {
29.             synchronized (LazyMan.class) {
30.                 if (lazyMan == null) {
31.                     lazyMan = new LazyMan(); // 实例化对象不能够保证原子性，所以加上了volatile关键字，不会产生指令重排
32.                     /**
33.                      * 对象的基本创建过程
34.                      * 1.分配内存空间
35.                      * 2.执行构造方法，初始化对象
36.                      *
37.                      * 123
38.                      * 132 A线程
39.                      *     B线程指向A的地址空间，产生了虚无操作，但是lazyMan还没有完成构造
40.                      */
41.                 }
42.             }
43.         }
44.         return lazyMan;
45.     }
47.     //反射
48.     public static void main(String[] args) throws Exception {
49. //        LazyMan instance = LazyMan.getInstance();
50.         Field blog1 = LazyMan.class.getDeclaredField("blog");
51.         blog1.setAccessible(true);
52.         Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
53.         declaredConstructor.setAccessible(true);
54.         LazyMan instance = declaredConstructor.newInstance();
55.         blog1.set(instance,false);
56.         LazyMan instance1 = declaredConstructor.newInstance();
57.         blog1.set(instance1,false);
58.         System.out.println(instance);
59.         System.out.println(instance1);
60.     }
61. }

复制代码

三.静态内部类单例

1. package single;
3. //静态内部类
4. public class Holder {
6.     private Holder() {
8.     }
9.     public static Holder getInstance() {
10.         return InnerClass.HOLDER;
11.     }
13.     public static class InnerClass{
14.         private final static Holder HOLDER = new Holder();
15.     }
17. }

复制代码

四.枚举单例

1. package single;
3. import java.lang.reflect.Constructor;
5. /*
6.     枚举的class文件中确实有无参构造器，但是通过jad反编译成java文件，
7.     发现里面有String和int的有参构造，通过无参无法抛出"Cannot reflectively create enum objects"
8. */
10. public enum EnumSingle {
12.     INSTANCE;
13.     public EnumSingle getInstance() {
14.         return INSTANCE;
15.     }
16. }
18. class Test{
20.     public static void main(String[] args) throws Exception {
21.         EnumSingle instance1 = EnumSingle.INSTANCE;
22.         Constructor<EnumSingle> constructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
23.         constructor.setAccessible(true);
24.         EnumSingle instance2 = constructor.newInstance();
25.         System.out.println(instance1);
26.         System.out.println(instance2);
27.     }
28. }

复制代码

• 因为反射不能破解枚举单例
  
  
• 并且尝试通过反射来破坏枚举单例，抛出异常却不是上述图片
  Constructor constructor = EnumSingle.class.getDeclaredConstructor(null);参数为null是因为，在.class文件里，我们发现枚举有无参构造
  
  
• 然后我们得到了不一样的异常
  它提示没有这个空参的构造方法
  
• 我们进入.class文件，通过命令：javap -p EnumSingle.class 通过反编译得到.java文件的表现形式
  
  
• 既然反编译解决不了这个问题，我们需要通过更专业的工具jad.exe得到他的.java文件，一探究竟
  输入cmd，在dos窗口输入：jad -sjava EnumSingle.class 得到EnumSingle.java文件，打开.java文件发现枚举有一个是有参构造，而不是无参构造
  
  
• 一个类型为String，另外一个为int，然后通过反射来试图破解枚举单例
  

• 这次的报错，跟之前通过反射的信息是一致的了
  
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！