java中聊聊单例模式 - 设计模式（二）

红太狼 2023-10-07 16:11 31阅读 0赞

## 什么是单例模式 ##

保证系统运行中，应⽤该模式的类只有⼀个对象实例
    全局唯一

## 使⽤场景 ##

业务系统全局只需要⼀个对象实例，⽐如发号器
    redis连接对象
    Spring IOC容器中的bean默认就是单例
    spring @autowire的依赖注⼊对象默认都是单例的

## 如何写一个单例模式 ##

1.将构造函数私有化
    2.通过静态方法获取一个唯一实例
    3.保证线程安全
    4.防止反序列化造成的新实例等

## 饿汉式 ##

JDK中Runtime类 饿汉⽅式  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw_size_16_color_FFFFFF_t_70]

// 模仿着Runtime实现
    /**
     * 饿汉 ： 声明静态时已经初始化，在获取对象之前就初始化
     */
    public class SingleHungerPattern {
        
    
    	//  3.声明静态时已经初始化，在获取对象之前就初始化，没有线程安全问题
        private static SingleHungerPattern instance = new SingleHungerPattern();
        
    	// 2.通过静态方法获取一个唯一实例
        public static SingleHungerPattern getInstance(){
        
            return instance;
        }
    	// 1.私有构造函数
        private SingleHungerPattern(){
        
            System.out.println("SingleHungerPattern实例化");
        }
    
        public static void main(String[] args) {
        
            SingleHungerPattern instance1 = SingleHungerPattern.getInstance();
            SingleHungerPattern instance2 = SingleHungerPattern.getInstance();
            System.out.println(instance1);
            System.out.println(instance2);
        }
    }

![在这里插入图片描述][20210418160332515.png]

## 懒汉式 ##

### DCL 双重检查锁 ###

/**
     * 懒汉 就是所谓的懒加载，延迟创建对象
     * 最多使用 ： DCL 双重检查锁
     */
    public class SingleLazyPattern {
        
    
        /**
         * 3. 使用 volatile 保证线程安全
         * 禁止指令重排
         * 保证可见性
         * 不保证原子性
         */
        private static volatile SingleLazyPattern instance;
        // 1.私有构造函数
        private SingleLazyPattern(){
        
            System.out.println("SingleLazyPattern实例化了");
        }
    
        /**
         *  2.通过静态方法获取一个唯一实例
         *  DCL 双重检查锁定 （Double-CheckedLocking）
         *  在多线程情况下保持⾼性能
         */
        public static SingleLazyPattern getInstance(){
        
            if(instance == null){
        
                synchronized (SingleLazyPattern.class){
        
                    if(instance == null){
        
                    // 1. 分配内存空间 2、执行构造方法，初始化对象 3、把这个对象指向这个空间
                        instance = new SingleLazyPattern();
                    }
                }
            }
            return instance;
        }
    
    
        public static void main(String[] args) {
        
            for (int i = 0; i < 5; i++) {
        
                new Thread(()->{
        
                    SingleLazyPattern.getInstance();
                }).start();
            }
        }
    
    }

### 静态内部类 ###

/**
     * 静态内部类
     */
    public class StaticInnerClass {
        
    
        // 1.私有构造函数
        private StaticInnerClass(){
        
            System.out.println("StaticInnerClass实例化");
        }
    
        // 2.通过静态方法获取一个唯一实例
        public static StaticInnerClass getInstance(){
        
            return innerClass.instance;
        }
    
        // 3.保证线程安全  调用 StaticInnerClass.instance 的时候，才会对单例进行初始化
        private static class innerClass{
        
            private final static StaticInnerClass instance = new StaticInnerClass();
        }
    
        public static void main(String[] args) {
        
            for (int i = 0; i < 5; i++) {
        
                new Thread(()->{
        
                     StaticInnerClass.getInstance();
                }).start();
            }
        }
    
    }

### 使用枚举 ###

枚举也是类，并且还继承了java.lang.Enum。
    由汇编可以看出，枚举的初始化过程是在静态代码块中进行，
    我们知道，静态代码块只在类首次加载的时候执行一次，final域保证引用地址不会改变。
    同时，我们也没有看到有公有的构造方法，客户端也就不能创建新的实例，
    由此可见，枚举类型具有实例受限的特性。
    解决单例的并发问题，主要解决的就是初始化过程中的线程安全问题。
    所以，由于枚举的以上特性，枚举实现的单例是天生线程安全的。

/**
     * 使用枚举获取单例
     */
    
    public enum SingleEnum {
        
    
        Instance;
    
        SingleEnum(){
        
            System.out.println("SingleEnum实例化了");
        }
    
        public static SingleEnum getInstance(){
        
            return Instance;
        }
    
        public static void main(String[] args) {
        
            SingleEnum instance1 = SingleEnum.getInstance();
            SingleEnum instance2 = SingleEnum.getInstance();
            System.out.println(instance1);
            System.out.println(instance2);
        }
    
    }

## java中有几种可以创建对象的方式 ##

1、通过new语句实例化一个对象
    2、通过反射机制
    3、通过clone（）创建对象
    4、通过反序列化的方式创建对象

## 思考 那么以上的四种创建对象的方式能不能破坏单例模式呢 ##

构造器私有已经无法通过new 创建对象了

## 序列化会破坏单例模式 ##

链接: [单例、序列化和readResolve()方法][readResolve].  
链接: [Java 之 Serializable 序列化和反序列化的概念,作用的通俗易懂的解释][Java _ Serializable].

import java.io.*;
    
    public class SingleHungerPattern implements Serializable {
        
    
        //  3.声明静态时已经初始化，在获取对象之前就初始化，没有线程安全问题
        private static SingleHungerPattern instance = new SingleHungerPattern();
    
        // 2.通过静态方法获取一个唯一实例
        public static SingleHungerPattern getInstance(){
        
            return instance;
        }
        // 1.私有构造函数
        private SingleHungerPattern(){
        
            System.out.println("SingleHungerPattern实例化");
        }
    
        public static void main(String[] args) throws Exception {
        
            SingleHungerPattern instance1 = SingleHungerPattern.getInstance();
            System.out.println(instance1);
            serialize(instance1);
            SingleHungerPattern instance2 = deserialize();
            System.out.println(instance2);
        }
    
        /**
         * 序列化
         */
        private static void serialize(SingleHungerPattern instance) throws IOException {
        
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("d:/flyPig.txt")));
            oos.writeObject(instance);
            oos.close();
            System.out.println("对象序列化成功！");
        }
    
        /**
         * 反序列化
         */
        private static SingleHungerPattern deserialize() throws Exception {
        
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("d:/flyPig.txt")));
            SingleHungerPattern instance = (SingleHungerPattern) ois.readObject();
            System.out.println("对象反序列化成功！");
            return instance;
        }
        
    
    }

![在这里插入图片描述][20210428164427325.png]

### 如何防止序列化破坏单例模式 ###

/**
        *若目标类有readResolve方法，那就通过反射的方式调用要被反序列化的类中的readResolve方法，返回一个
        *对象，然后把这个新的对象复制给之前创建的obj（即最终返回的对象）。那被反序列化的类中的
        * readResolve 方法里是什么？就是直接返回我们的单例对象。
        * 防止序列化造成的破坏
        * @return
        */
        private Object readResolve() {
        
            return instance;
        }

## 克隆也会破坏单例模式 ##

public class SingleHungerPattern implements Cloneable{
        
    
        //  3.声明静态时已经初始化，在获取对象之前就初始化，没有线程安全问题
        private static SingleHungerPattern instance = new SingleHungerPattern();
    
        // 2.通过静态方法获取一个唯一实例
        public static SingleHungerPattern getInstance(){
        
            return instance;
        }
        // 1.私有构造函数
        private SingleHungerPattern(){
        
            System.out.println("SingleHungerPattern实例化");
        }
    
        public static void main(String[] args) throws Exception {
        
            SingleHungerPattern instance1 = SingleHungerPattern.getInstance();
            System.out.println(instance1);
            SingleHungerPattern instance2 = (SingleHungerPattern)instance1.clone();
            System.out.println(instance2);
        }
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
        
            return super.clone();//单例实现了克隆接口 可以利用反射破坏单例
            //return instance;//解决办法 即使通过反射调用clone方法 获取到的依然是原来的实例对象
        }
        
    }

### 分别对以上四种方式进行反射 ###

#### 饿汉- 被破坏 ####

import java.lang.reflect.Constructor;
    import java.lang.reflect.InvocationTargetException;
    
    public class Test {
        
        public static void main(String[] args) throws NoSuchMethodException,
                IllegalAccessException, InvocationTargetException, InstantiationException {
        
            SingleHungerPattern instance1 = SingleHungerPattern.getInstance();
            Constructor<SingleHungerPattern> declaredConstructor = SingleHungerPattern.class.
                    getDeclaredConstructor(null);
            declaredConstructor.setAccessible(true);
            SingleHungerPattern instance2 = declaredConstructor.newInstance();
            System.out.println(instance1);
            System.out.println(instance2);
        }
    }

#### DCL 双重检查锁- 被破坏 ####

import java.lang.reflect.Constructor;
    import java.lang.reflect.InvocationTargetException;
    
    public class Test {
        
    
        public static void main(String[] args) throws NoSuchMethodException,
                IllegalAccessException, InvocationTargetException, InstantiationException {
        
            SingleLazyPattern instance1 = SingleLazyPattern.getInstance();
            Constructor<SingleLazyPattern> declaredConstructor = SingleLazyPattern.class.
                    getDeclaredConstructor(null);
            declaredConstructor.setAccessible(true);
            SingleLazyPattern instance2 = declaredConstructor.newInstance();
            System.out.println(instance1);
            System.out.println(instance2);
        }
    }

#### 静态内部类- 被破坏 ####

import java.lang.reflect.Constructor;
    import java.lang.reflect.InvocationTargetException;
    
    public class Test {
        
    
        public static void main(String[] args) throws NoSuchMethodException,
                IllegalAccessException, InvocationTargetException, InstantiationException {
        
            StaticInnerClass instance1 = StaticInnerClass.getInstance();
            Constructor<StaticInnerClass> declaredConstructor = StaticInnerClass.class.
                    getDeclaredConstructor(null);
            declaredConstructor.setAccessible(true);
            StaticInnerClass instance2 = declaredConstructor.newInstance();
            System.out.println(instance1);
            System.out.println(instance2);
        }
    
    }

#### 枚举 - 不会破坏 ####

import java.lang.reflect.Constructor;
    import java.lang.reflect.InvocationTargetException;
    
    public class Test {
        
        public static void main(String[] args) throws NoSuchMethodException,
                IllegalAccessException, InvocationTargetException, InstantiationException {
        
            SingleEnum instance1 = SingleEnum.getInstance();
            Constructor<SingleEnum> declaredConstructor = SingleEnum.class.
                    getDeclaredConstructor(null);
            declaredConstructor.setAccessible(true);
            SingleEnum instance2 = declaredConstructor.newInstance();
            System.out.println(instance1);
            System.out.println(instance2);
        }
    }

## Effective java 书中 ##

链接: [为什么要用枚举实现单例模式（避免反射、序列化问题）][Link 1].

第89条：对于实例控制，枚举类型优先于readResolve

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2021041815594687.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw,size_16,color_FFFFFF,t_70
[20210418160332515.png]: https://img-blog.csdnimg.cn/20210418160332515.png
[readResolve]: https://zhuanlan.zhihu.com/p/136769959
[Java _ Serializable]: https://blog.csdn.net/qq_27093465/article/details/78544505
[20210428164427325.png]: https://img-blog.csdnimg.cn/20210428164427325.png
[Link 1]: https://blog.csdn.net/qq_37960603/article/details/104060119