单例模式深入学习

妖狐艹你老母 2023-02-27 10:31 45阅读 0赞

### 单例模式：该类负责创建自己的对象，同时确保只有单个对象被创建。 ###

##### 饿汉模式 #####

//可能会浪费资源
    public class Student { 
        private static final Student student = new Student();
        private Student() { 
    
        }
        public static Student getStudent(){ 
            return student;
        }
    
        public static void main(String[] args) { 
            Student student = Student.getStudent();
            Student student1 = Student.getStudent();
            System.out.println(student);
            System.out.println(student1);
        }
    }

可以得知他们是一个对象。

##### 懒汉模式 #####

public class LazyManTest { 
    
        private static LazyManTest lazyManTest;
        private LazyManTest(){ 
            System.out.println(Thread.currentThread().getName()+"创建对象");
        }
        public static LazyManTest getInstance(){ 
            if (lazyManTest == null){ 
                return lazyManTest = new LazyManTest();
            }
            return lazyManTest;
        }
        public static void main(String[] args) { 
            LazyManTest instance = LazyManTest.getInstance();
            System.out.println(instance);
            LazyManTest instance2 = LazyManTest.getInstance();
            System.out.println(instance2);
        }
    
    }

###### 然而在多线程情况下，他就不安全了，10条线程同时去获取它的实例对象。 ######

for (int i = 0; i < 10; i++) { 
        new Thread(()->{ 
          LazyManTest.getInstance();
        },String.valueOf(i)).start();
    }

运行结果：1创建对象  
4创建对象  
3创建对象  
2创建对象  
0创建对象

##### 那么我们如何保证其线程安全哪？ #####

1.我们可以使用synchronized锁

public synchronized static LazyManTest getInstance(){ 
        if (lazyManTest == null){ 
            return lazyManTest = new LazyManTest();
        }
        return lazyManTest;
    }

2.双重检测锁模式，锁住一个类，只有一个实例

public static LazyManTest getInstance(){ 
        if (lazyManTest == null){ 
            synchronized (LazyManTest.class){ 
                if (lazyManTest == null){ 
                    return lazyManTest = new LazyManTest();
                }
            }
        }
        return lazyManTest;
    }

#### 3.上面的代码还是不安全的，lazyManTest = new LazyManTest()；创建对象这个语句他不是原子性的，分为三步，（1）分配内存空间（2）执行构造方法（3）引用指向内存空间地址。计算机我们希望执行顺序是123，但是计算机会进行指令重排，132。当AB两条线程，A线程先执行13步骤，2还没有执行时候，那么B线程执行lazyManTest ！= null,return lazyManTest ####

##### 此时A线程还没执行完，B线程直接返回对象，会出错。所以我们要禁止指令重排。使用Volatile关键字。 #####

private static volatile LazyManTest lazyManTest;

##### 但是在Java反射中，我们依然可以创建两个对象，如下 #####

public class LazyManTest { 
    
        private static volatile LazyManTest lazyManTest;
        private LazyManTest(){ 
            System.out.println(Thread.currentThread().getName()+"创建对象");
        }
        public static LazyManTest getInstance(){ 
            if (lazyManTest == null){ 
                synchronized (LazyManTest.class){ 
                    if (lazyManTest == null){ 
                        return lazyManTest = new LazyManTest();
                    }
                }
            }
            return lazyManTest;
        }
        public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { 
            //获取 LazyManTest无参构造器
            Constructor<LazyManTest> constructor = LazyManTest.class.getDeclaredConstructor(null);
            //将其私有的设置权限更改
            constructor.setAccessible(true);
            //创建对象
            LazyManTest instance1 = constructor.newInstance();
            LazyManTest instance = LazyManTest.getInstance();
            System.out.println(instance);
            System.out.println(instance1);
        }
    
    }

运行结果：main创建对象  
main创建对象  
com.wang.demo10.LazyManTest@1540e19d  
com.wang.demo10.LazyManTest@677327b6

##### 此时我们如何应对呢？我们可以在构造器中使用锁 #####

private LazyManTest(){ 
    
        synchronized (LazyManTest.class){ 
            if (lazyManTest != null){ 
                throw new RuntimeException("反射机制正在通过构造器获取对象");
            }
        }
        
        System.out.println(Thread.currentThread().getName()+"创建对象");
    }

##### 这时，我们创建对象都用反射机制来创建对象。我们依然可以创建两个对象。 #####

##### 因为我们没有调用public static LazyManTest getInstance()这个方法，所以lazyManTest总是空的 #####

Constructor<LazyManTest> constructor = LazyManTest.class.getDeclaredConstructor(null);
    //将其私有的设置权限更改
    constructor.setAccessible(true);
    LazyManTest instance1 = constructor.newInstance();
    LazyManTest instance = constructor.newInstance();
    System.out.println(instance);
    System.out.println(instance1);

##### 那么此时我们如何应对哪？我们可以使用信号灯法。定义flag=false,第一次创建对象，flag = false正常执行设置flag=true,下一个在进行创建对象则会抛出异常。只会创建一个对象 #####

private static boolean flag = false;
    private LazyManTest(){ 
        synchronized (LazyManTest.class){ 
            if (flag == false){ 
                flag = true;
            }else { 
                throw new RuntimeException("反射机制正在通过构造器获取对象");
            }
        }
    
        System.out.println(Thread.currentThread().getName()+"创建对象");
    }

##### 通常这个flag是会被加密的，但是总有解密的。解密之后我们再通过反射获取这个对象，修改它的值。依然可以创建两个对象。 #####

public class LazyManTest { 
    
        private static volatile LazyManTest lazyManTest;
        private static boolean flag = false;
        private LazyManTest(){ 
            synchronized (LazyManTest.class){ 
                if (flag == false){ 
                    flag = true;
                }else { 
                    throw new RuntimeException("反射机制正在通过构造器获取对象");
                }
            }
    
            System.out.println(Thread.currentThread().getName()+"创建对象");
        }
        public static LazyManTest getInstance(){ 
            if (lazyManTest == null){ 
                synchronized (LazyManTest.class){ 
                    if (lazyManTest == null){ 
                        return lazyManTest = new LazyManTest();
                    }
                }
            }
            return lazyManTest;
        }
        public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException { 
            //获取 LazyManTest无参构造器
            Constructor<LazyManTest> constructor = LazyManTest.class.getDeclaredConstructor(null);
            //将其私有的设置权限更改
            constructor.setAccessible(true);
            //获取 flag的属性
            Field flag = LazyManTest.class.getDeclaredField("flag");
            //修改权限
            flag.setAccessible(true);
            //创建对象
            LazyManTest instance1 = constructor.newInstance();
            //重新修改flag的值为FALSE， 这个falg总是false
            flag.set(instance1,false);
            LazyManTest instance = constructor.newInstance();
            System.out.println(instance);
            System.out.println(instance1);
        }
    
    }

运行结果：main创建对象  
main创建对象  
com.wang.demo10.LazyManTest@677327b6  
com.wang.demo10.LazyManTest@14ae5a5

#### enum是什么？它本身是个class类，且它就是一个单例的，我们不能通过反射去获取对象，我们点进去target可以看到它的构造器是空的，如果反射获取，会报一个错，但是通过反编译我们会发现他构造函数有两个参数，再通过反射获取对象，会报不能通过反射获取枚举对象的Exception ####