单例模式 单例模式饿汉式package com.sw.single; /** * @Author suaxi * @Date 2021/2/21 18:57 * 饿汉式单例 */ public class Hungry { private byte[] data1 = new byte[1024 * 1024]; private byte[] data2 = new byte[1024 * 1024]; private byte[] data3 = new byte[1024 * 1024]; private byte[] data4 = new byte[1024 * 1024]; private Hungry(){ } private final static Hungry hungry = new Hungry(); public static Hungry getHungry() { return hungry; } } 懒汉式package com.sw.single; import java.lang.reflect.Constructor; import java.lang.reflect.Field; /** * @Author suaxi * @Date 2021/2/21 18:59 * 懒汉式单例 */ public class Lazy { //通过私有参数保证单例模式的安全 private static boolean flag = false; private Lazy() { synchronized (Lazy.class){ if (flag == false){ flag = true; }else { throw new RuntimeException("不要试图使用反射破环单例模式"); } } System.out.println(Thread.currentThread().getName() + " ok"); } private volatile static Lazy lazy; //双重检测锁模式的 懒汉式单例 DCL懒汉式 public static Lazy getInstance(){ if (lazy == null){ synchronized (Lazy.class){ if (lazy == null){ lazy = new Lazy(); //不是一个原子性操作 /* 不是一个原子性操作，可能存在问题 new 对象的过程： 1、分配内存空间 2、执行构造方法。初始化对象 3、把对象指向这个空间 一般来说的执行过程 123 132 A 可能出现指令重排 B B线程执行时，由于A线程中的指令重排导致的问题，此时Lazy还没有完成构造 解决办法：volatile */ } } } return lazy; } //多线程并发 // public static void main(String[] args) { // for (int i = 0; i < 10; i++) { // new Thread(() ->{ // Lazy.getInstance(); // }).start(); // } // } //反射 可以破环单例模式 public static void main(String[] args) throws Exception { //Lazy instance01 = Lazy.getInstance(); //第一次 //第三次，通过反射获取私有字段flag Field flag = Lazy.class.getDeclaredField("flag"); flag.setAccessible(true); Constructor<Lazy> declaredConstructor = Lazy.class.getDeclaredConstructor(null); declaredConstructor.setAccessible(true); //无视私有构造 //第二次，两个对象都通过以下方式构造，又破坏了三重检测锁的单例模式 Lazy instance01 = declaredConstructor.newInstance(); flag.set(instance01,false); //此处又破坏了 Lazy instance02 = declaredConstructor.newInstance(); System.out.println(instance01); //com.sw.single.Lazy@74a14482 System.out.println(instance02); //com.sw.single.Lazy@1540e19d } /* 1、第一次破环单例模式，通过反射创建instance对象 2、加上三重检测锁，又通过全部使用反射创建对象来破坏（第二次） 3、设置私有变量 flag，通过反射获取私有变量字段，又破坏了单例 */ } 静态内部类package com.sw.single; /** * @Author suaxi * @Date 2021/2/21 19:48 * 静态内部类 */ public class Holder { private Holder(){ } public static Holder getInstance(){ return InnerClass.holder; } public static class InnerClass{ private static final Holder holder = new Holder(); } } 枚举package com.sw.single; import java.lang.reflect.Constructor; /** * @Author suaxi * @Date 2021/2/21 20:10 */ public enum EnumSingle { INSTANCE; public EnumSingle getInstance(){ return INSTANCE; } } class Test{ public static void main(String[] args) throws Exception { EnumSingle instance01 = EnumSingle.INSTANCE; Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class); declaredConstructor.setAccessible(true); EnumSingle instance02 = declaredConstructor.newInstance(); //获取空参的反射报错 没有无参构造器 // java.lang.NoSuchMethodException: com.sw.single.EnumSingle.<init>() //EnumSingle.class.getDeclaredConstructor(String.class,int.class); //报错 java.lang.IllegalArgumentException: Cannot reflectively create enum objects //反射不能破坏枚举 System.out.println(instance01 == instance02); } } 注:需通过jad反编译，EnumSingle.class.getDeclaredConstructor(String.class,int.class);反射获取有参构造才能得出java.lang.IllegalArgumentException: Cannot reflectively create enum objects（反射不能破坏枚举），常规的通过反射获取无参构造只会报错java.lang.NoSuchMethodException