【Java设计模式】二、单例模式

亦凉 2024-04-23 15:52 90阅读 0赞

#### 文章目录 ####

*  0、单例模式
 *  1、饿汉式
 *  2、懒汉式
 *  3、双重检查
 *  4、静态内部类
 *  5、枚举
 *  6、单例模式的破坏：序列化和反序列化
 *  7、单例模式的破坏：反射
 *  8、单例模式的实际应用

设计模式即总结出来的一些最佳实现。GoF(四人组) 书中提到23种设计模式，可分为三大类：

*  **创建型模式**：隐藏了创建对象的过程，通过逻辑方法进行创建对象，使用者不用关注对象的创建细节（对那种属性很多，创建麻烦的对象尤其好用）
 *  **结构型模式**：主要关注类和对象的组合关系。将类或对象按某种布局组成更大的结构
 *  **行为型模式**：主要关注对象之间的通信与配合

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

## 0、单例模式 ##

*  单例模式即在程序中想要保持一个实例对象，让某个类只有一个实例
 *  单例类必须自己创建自己唯一的实例，并对外提供
 *  优点：减少了内存开销

单例模式的实现，有以下几种思路：

## 1、饿汉式 ##

*  **类加载就会导致该单实例对象被创建**
 *  通过静态代码块或者静态变量直接初始化

方式一：静态成员变量的方式

public class HungrySingleton {
        
    
        private static final HungrySingleton hungrySingleton = new HungrySingleton();
    	
    	//私有的构造方法，只能本类调用，不给外界用
        private HungrySingleton(){
        
    
        }
    	//提供一个获取实例的方法给外界
        public static HungrySingleton getInstance(){
        
            return hungrySingleton;
        }
    }

方式二：静态代码块

public class HungrySingleton {
        
    
       
        private static HungrySingleton hungrySingleton = null;
    
        //  静态代码块中进行赋值
        static {
        
            hungrySingleton = new HungrySingleton();
        }
    	//私有的构造方法，只能本类调用，不给外界用
        private HungrySingleton(){
        
    
        }
    	//提供一个获取实例的方法给外界
        public static HungrySingleton getInstance(){
        
            return hungrySingleton;
        }
    }

以上两种方式，对象会随着类的加载而创建，如果这个对象后来一直没被用，就有点白占内存了。

## 2、懒汉式 ##

**类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建**

懒汉式方式一：线程不安全

public class LazySingleton  {
        
        private static LazySingleton lazySingleton = null;
    
        /**
         * 私有的构造方法，保证出了本类就不能再被调用，以防直接去创建对象
         */
        private LazySingleton() {
        
    
        }
    
        /**
         * 单例对象的获取
         */
        public static LazySingleton getInstance() {
        
            if (lazySingleton == null) {
        
                lazySingleton = new LazySingleton();
            }
            return lazySingleton;
        }
    
    }

测试类启两个线程获取对象：

public class Test {
        
        public static void main(String[] args) {
        
            new Thread(() -> {
        
                LazySingleton instance = LazySingleton.getInstance();
                System.out.println(Thread.currentThread().getName() + "-->" + instance);
            }, "t1").start();
            new Thread(() -> {
        
                LazySingleton instance = LazySingleton.getInstance();
                System.out.println(Thread.currentThread().getName()+ "-->" + instance);
            }, "t2").start();
        }
    }

发现可能出现获取到两个不同对象的情况，这是因为线程安全问题：

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

两个线程A、B，同时执行`完`IF 这一行，被挂起，再被唤醒时继续往下执行，就会创建出两个不同的实例对象。那最先想到的应该是synchronized关键字解决，但这样性能低下，因为不管对象是否为null，每次都要等着获取锁。

//性能低下，一刀切，不可行
    public static synchronized LazySingleton getInstance() {
        
         if (lazySingleton == null) {
        
             lazySingleton = new LazySingleton();
         }
         return lazySingleton;
     }

## 3、双重检查 ##

**通过两个IF判断，加上同步锁进行实现。**（懒汉式方式二：双重检查）

public class DoubleCheckSingleton {
        
    
        private static DoubleCheckSingleton doubleCheckSingleton;
    
        /**
         * 私有的构造方法，保证出了本类就不能再被调用，以防直接去创建对象
         */
        private DoubleCheckSingleton(){
        
    
        }
        public static DoubleCheckSingleton getInstance(){
        
            if(doubleCheckSingleton == null){
        
                synchronized (DoubleCheckSingleton.class){
        
                    if(doubleCheckSingleton == null){
        
                        doubleCheckSingleton = new DoubleCheckSingleton();
                    }
                }
            }
            return doubleCheckSingleton;
        }
    }

如此，再有A、B两个线程同时执行到第一个IF，只能有一个成功创建对象，另一个获取到锁后，第二重判断会告诉它已经有对象实例了。**而亮点则在于，对象初始化完成后，后面来获取对象的线程不用等着拿锁，第一个IF就能告诉它已有对象，不用再等锁了。**

以上双端检锁虽然线程安全，但问题是，JVM指令重排序后，可能出现空指针异常，可再加volatile关键字（volatile的可见性和有序性，这里用它的有序性）

//...
    private static volatile DoubleCheckSingleton doubleCheckSingleton;
    //...

## 4、静态内部类 ##

在单例类中，通过**私有的**静态内部类，创建单例对象（加private修饰词的，出了本类无法调用和访问）。这也是懒汉式的第三种方式。

public class StaticInnerClassSingleton {
        
    
        /**
         * 私有的静态内部类实例化对象
         * 给内部类的属性赋值一个对象
         */
        private static class InnerClass{
        
            private static StaticInnerClassSingleton staticInnerClassSingleton = new StaticInnerClassSingleton();
        }
    
        /**
         * 私有的构造方法，保证出了本类就不能再被调用，以防直接去创建对象
         */
        private StaticInnerClassSingleton(){
        
    
        }
    	/**
         * 对外提供获取实例的方法
         */
        public static StaticInnerClassSingleton getInstance(){
        
            return InnerClass.staticInnerClassSingleton;
        }
    }

外部类StaticInnerClassSingleton被加载时，其对象不一定被初始化，因为内部类没有被主动使用到。直到调用getInstance方法时，静态内部类InnerClass被加载，完成实例化。

> 静态内部类在被加载时，不会立即实例化，而是在第一次使用时才会被加载并初始化。

**JVM在加载外部类的过程中，不会加载静态内部类，只有内部类的属性或方法被调用时才会被加载，并初始化其静态属性。** 这种延迟加载的特性，使得我们可以通过静态内部类来实现在需要时创建单例对象。这种方式没有线程安全问题，也没有性能影响和空间的浪费。

## 5、枚举 ##

*  单例模式的最佳实现方式
 *  枚举类型是线程安全的，并且只会装载一次
 *  可有效防止对单例模式的破坏
 *  属于饿汉式

public enum EnumSingleton {
        
        INSTANCE;
    
        public static EnumSingleton getInstance(){
        
            return INSTANCE;
        }
    }

## 6、单例模式的破坏：序列化和反序列化 ##

通过流将单例对象，序列化到文件中，然后再反序列化读取出来。发现通过反序列化方式创建出来的对象内存地址，和原对象不一样。或者对象序列化到文件后，两次反序列化得到的对象也不一样，单例模式被破坏。

public class TestSerializer {
        
    
        public static void main(String[] args) throws Exception {
        
            //懒汉式
            LazySingleton instance = LazySingleton.getInstance();
            //把对象序列化到文件中
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("singleton"));
            oos.writeObject(instance);
            //从文件中反序列化对象
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("singleton"));
            LazySingleton objInstance = (LazySingleton) ois.readObject();
            System.out.println(instance);
            System.out.println(objInstance);
            System.out.println(instance == objInstance);
        }
    }

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

可以发现单例模式的五种实现方式中，只有枚举不会被破坏单例模式。如果非要用其他几种模式，可以加`readResolve`方法来重写反序列化逻辑。**因为反序列化创建对象时，是通过反射创建的，反射会调用readResolve方法，并将其返回值做为反序列化的结果。** 没有重写readResolve方法时，会通过反射创建一个新的对象，从而破坏了单例模式。这一点在对象流ObjectInputStream的源码可看出：

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

public class LazySingleton implements Serializable {
        
        private static LazySingleton lazySingleton = null;
    
        /**
         * 私有的构造方法，保证出了本类就不能再被调用，以防直接去创建对象
         */
        private LazySingleton() {
        
        }
    
        /**
         * 单例对象的获取
         */
        public static LazySingleton getInstance() {
        
            if (lazySingleton == null) {
        
                lazySingleton = new LazySingleton();
            }
            return lazySingleton;
        }
    
        private Object readResolve(){
        
            return lazySingleton;
        }
    
    
    }

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

也可考虑使用[@JsonCreator][JsonCreator]注解。

## 7、单例模式的破坏：反射 ##

*  通过字节码对象，创建构造器对象
 *  通过构造器对象，初始化单例对象
 *  由于单例对象的构造方法是private私有的，调用构造器中的方法，赋予权限，创建单例对象

注意私有修饰词时，反射会IllegalAccessException

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

处理下private问题，用懒汉模式验证：

public class TestReflect {
        
        public static void main(String[] args) throws Exception{
        
            //创建字节码对象
            Class<LazySingleton> clazz = LazySingleton.class;
            //构造器对象
            Constructor<LazySingleton> constructor = clazz.getDeclaredConstructor();
            //赋予权限
            constructor.setAccessible(true);
            //解决了私有化问题，获取实例对象
            LazySingleton o1 = constructor.newInstance();
            //再次反射
            LazySingleton o2 = constructor.newInstance();
            System.out.println(o1);
            System.out.println(o2);
            System.out.println(o1 == o2);
    
        }
    }

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

用枚举的方式验证：

public class TestEnumReflect {
        
        public static void main(String[] args) throws Exception {
        
            Class<EnumSingleton> clazz = EnumSingleton.class;
            //枚举下的单例模式，创建构造方法时，需要给两个参数，薮泽NoSuchMethodException
            //这两个参数是源码中的体现，一个是String，一个是int
            Constructor<EnumSingleton> constructor = clazz.getDeclaredConstructor(String.class, int.class);
            constructor.setAccessible(true);
            EnumSingleton instanceReflect = constructor.newInstance("test",1234);
            EnumSingleton instanceSingleton = EnumSingleton.getInstance();
            System.out.println(instanceReflect);
            System.out.println(instanceSingleton);
            System.out.println(instanceReflect == instanceSingleton);
    
        }
    }

运行报错：`Cannot reflectively create enum objects`，即反射创建枚举的单例对象，是不允许的：

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

在其他单例模式的实现方式里，也可以实现不允许通过反射创建对象，反射靠拿构造方法对象，调整下构造方法（比如双重检锁）：

public class DoubleCheckSingleton {
        
    
        private static DoubleCheckSingleton doubleCheckSingleton;
    
        /**
         * 私有的构造方法，保证出了本类就不能再被调用，以防直接去创建对象
         */
        private DoubleCheckSingleton(){
        
    		if (doubleCheckSingleton != null) {
        
    			throw new RuntimeException("不允许创建多个对象");
    		}
        }
        public static DoubleCheckSingleton getInstance(){
        
            if(doubleCheckSingleton == null){
        
                synchronized (DoubleCheckSingleton.class){
        
                    if(doubleCheckSingleton == null){
        
                        doubleCheckSingleton = new DoubleCheckSingleton();
                    }
                }
            }
            return doubleCheckSingleton;
        }
    }

或者：

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

## 8、单例模式的实际应用 ##

JDK的Runtime类就是饿汉式的单例模式：

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

PS：Runtime类的简单使用 --> 执行DOS命令并获取结果

public class RuntimeDemo {
        
    	public static void main(String[] args) throws IOException {
        
    		//获取Runtime类对象
    		Runtime runtime = Runtime.getRuntime();
    		//返回 Java 虚拟机中的内存总量。
    		System.out.println(runtime.totalMemory());
    		//返回 Java 虚拟机试图使用的最大内存量。
    		System.out.println(runtime.maxMemory());
    		//创建一个新的进程执行指定的字符串命令，返回进程对象
    		Process process = runtime.exec("ipconfig");
    		//获取命令执行后的结果，通过输入流获取
    		InputStream inputStream = process.getInputStream();
    		byte[] arr = new byte[1024 * 1024* 100];
    		//将流输入到数组，返回读到的字节个数
    		int b = inputStream.read(arr); 
    		//字节数组转字符串，指定下字符集为GBK
    		System.out.println(new String(arr,0 ,b ,"gbk"));
    	}
    }

[41cdfd13f33f4f29b6391a555e46921f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/17be61611fd94eec9293a31a367a4262.png
[7cfa48272c26437281c61870fecd8cc7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/1d958f6f7f0c425f9160510947e9ca62.png
[581a4e63ec7d420a8a3d3d22f7c21d70.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/b6e5e4736d904b9f803cda170dccea65.png
[af3a27201cf94981a1ecad1e2851e652.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/46e2b111be494165bd7775859ff30813.png
[d1dc62a2d1334a8a855a71971eac0fb0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/77248c57695b48129072859348a81076.png
[JsonCreator]: https://llg-notes.blog.csdn.net/article/details/134558738
[d36a2345f4ae470a80749e8c6eb270be.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/d580bd8089ed4a108880d777d2087d43.png
[aa565ae550b14444b06843eb0bb4f21d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/e7dc001716f14de38d3374d13148caa9.png
[d08178541ea247bc8b5c8c8f47b44b8f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/21292b617a7447228406e6ce81ee68aa.png
[1069ac9e0f5e4b26b81f9f058ac15ea6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/6df6a80172c74e00970bc9f7b933dddf.png
[c117f0ee781a420ca1294ad335fa4834.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/5b0adc53a24b4e74bed46c65cf279bfa.png