深入理解Java设计模式——单例模式

Bertha 。 2023-09-29 11:00 23阅读 0赞

#### 目录 ####

*  一、什么是单例模式
 *   *  1. 单例模式优缺点
 *  二、单例模式应用场景
 *  三、单例的七种写法
 *   *  1. 饿汉式
     *   *  1.1 优缺点
     *  2. 懒汉式(线程不安全)
     *  3. 懒汉式(线程安全)
     *  4. 双重检验锁(DCL)
     *  5. 静态内部类形式
     *  6. 枚举形式
     *  7. 使用容器管理
     *  8. 如何防止破坏单例
     *   *  8.1 使用反射技术破解单例
         *  8.2 如何防止被反射破解
         *  8.3 使用序列化技术破解单例
         *  8.4 如何防止被序列化技术破解

## 一、什么是单例模式 ##

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_size_20_color_FFFFFF_t_70_g_se_x_16]

### 1. 单例模式优缺点 ###

优点：  
1、单例类只有一个实例  
2、共享资源，全局使用  
3、节省创建时间，提高性能

缺点：可能存在线程不安全的问题

## 二、单例模式应用场景 ##

windows的任务管理器、网站的计数器、Web应用配置对象的读取、多线程的线程池

## 三、单例的七种写法 ##

分别是「饿汉」、「懒汉(非线程安全)」、「懒汉(线程安全)」、「双重校验锁」、「静态内部类」、「枚举」和「容器类管理、静态块初始化」

### 1. 饿汉式 ###

package com.demo.singleton.v1;
    
    /**
     * @Author: JYC
     * @Title: 饿汉式
     * @Description: TODO
     * @Date: 2022/4/20 10:11
     */
    public class SingletonV1 {
        
        /**
         * 饿汉式
         * 优点：先天性线程安全，当类初始化的时候，就被创建该对象。
         * 缺点：如果项目中使用过多的饿汉式会发生问题，项目在启动的时候会变得非常慢，存放在方法区占用内存比较大
         * 如果用户不使用该对象的时候，也会被提前创建好
         */
        private static SingletonV1 singLetonV1 = new SingletonV1();
    
        // 1. 单例模式是否可以让程序员初始化
        private SingletonV1() {
        
    
        }
    
        /**
         * 返回该对象的实例
         * @return
         */
        public static SingletonV1 getSingLetonV1() {
        
            return singLetonV1;
        }
    }

package com.demo.singleton.v1;
    
    /**
     * @Author: JYC
     * @Title: SingletonV1Test
     * @Description: TODO
     * @Date: 2022/4/20 10:35
     */
    public class SingletonV1Test {
        
        public static void main(String[] args) {
        
            SingletonV1 instance1 = SingletonV1.getSingLetonV1();
            SingletonV1 instance2 = SingletonV1.getSingLetonV1();
            System.out.println(instance1 == instance2); // 判断是否为同一个对象
        }
    
    }

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_size_18_color_FFFFFF_t_70_g_se_x_16]

#### 1.1 优缺点 ####

饿汉式  
优点：先天性线程是安全的，当类初始化的时候就会创建该对象。  
缺点：如果饿汉式使用过多，可能会影响项目启动的效率问题。

### 2. 懒汉式(线程不安全) ###

package com.demo.singleton.v2;
    
    /**
     * @Author: JYC
     * @Title: 懒汉式(线程不安全)
     * @Description: TODO
     * @Date: 2022/4/20 10:50
     */
    public class SingletonV2 {
        
        // 懒汉式 当真正需要使用该对象的时候才会被初始化
        private static SingletonV2 singletonV2;
    
        // 1. 单例模式是否可以让程序员初始化
        private SingletonV2() {
        
    
        }
    
        /**
         * 线程安全问题
         * 在多线程情况下，可能会被初始化多次
         * @return
         */
        public static SingletonV2 getSingletonV2() {
        
            // 当第一次singletonV2 等于null情况才会被初始化
            if (singletonV2 == null) {
        
                try {
        
                    Thread.sleep(2000);  //
                } catch (Exception e) {
        
    
                }
                singletonV2 = new SingletonV2();
            }
            return singletonV2;
        }
    }

package com.demo.singleton.v2;
    
    /**
     * @Author: JYC
     * @Title: 懒汉式，模拟多线程操作
     * @Description: TODO
     * @Date: 2022/4/20 10:54
     */
    public class SingletonV2Test {
        
        public static void main(String[] args) {
        
    //        SingletonV2 singleton1 = SingletonV2.getSingletonV2();
    //        SingletonV2 singleton2 = SingletonV2.getSingletonV2();
    //        System.out.println(singleton1 == singleton2); // 判断是否为同一个对象
    
            // 如何去模拟高并发情况下，懒汉式线程安全问题
            for (int i = 0; i < 100; i++) {
        
                new Thread(new Runnable() {
        
                    @Override
                    public void run() {
        
                        SingletonV2 singleton1 = SingletonV2.getSingletonV2();
                        System.out.println(Thread.currentThread().getName() + "，" + singleton1);
                    }
                }).start();
            }
        }
    }

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_size_19_color_FFFFFF_t_70_g_se_x_16]

### 3. 懒汉式(线程安全) ###

package com.demo.singleton.v2;
    
    /**
     * @Author: JYC
     * @Title: 懒汉式(线程安全)
     * @Description: TODO
     * @Date: 2022/4/20 10:50
     */
    public class SingletonV2 {
        
        // 懒汉式 当真正需要使用该对象的时候才会被初始化
        private static SingletonV2 singletonV2;
    
        // 1. 单例模式是否可以让程序员初始化
        private SingletonV2() {
        
    
        }
    
        /**
         * 创建和获取实例时上锁，可以解决线程安全问题，但是执行效率非常低
         * @return
         */
        public synchronized static SingletonV2 getSingletonV2() {
        
            try {
        
                Thread.sleep(2000);  //
            } catch (Exception e) {
        
    
            }
            // 当第一次singletonV2 等于null情况才会被初始化
            if (singletonV2 == null) {
        
                singletonV2 = new SingletonV2();
            }
            return singletonV2;
        }
    }

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_size_20_color_FFFFFF_t_70_g_se_x_16 1]

### 4. 双重检验锁(DCL) ###

package com.demo.singleton.v3;
    
    /**
     * @Author: JYC
     * @Title: SingletonV3
     * @Description: TODO
     * @Date: 2022/4/20 11:33
     */
    public class SingletonV3 {
        
        private static SingletonV3 singletonV3;
        // 双重检验锁，解决懒汉式读和写都加上锁的问题，缺点：第一次创建对象可能会比较慢
    
        private SingletonV3() {
        
    
        }
    
        /**
         * 读的不加锁，写的时候才会加锁
         */
        public static SingletonV3 getSingletonV3() {
        
    
            // 当多个线程同时在可能new对象的时候，才会加锁，保证线程安全问题
            if (singletonV3 == null) {
        
                try {
        
                    Thread.sleep(2000);  //
                } catch (Exception e) {
        
    
                }
                synchronized (SingletonV3.class) {
        
                    if (singletonV3 == null) {
         // 当前线程已经获取到锁了，再判断一下该对象是否已经初始化过，没有初始化过的创建
                        singletonV3 = new SingletonV3();
                    }
                }
            }
            return singletonV3;
        }
        // 双重检验锁的目的时什么？    解决懒汉式获取对象效率问题。
    }

package com.demo.singleton.v3;
    
    /**
     * @Author: JYC
     * @Title: 模拟多线程操作
     * @Description: TODO
     * @Date: 2022/4/20 11:57
     */
    public class SingletonV3Test {
        
        public static void main(String[] args) {
        
            // 如何去模拟高并发情况下，懒汉式线程安全问题
            for (int i = 0; i < 100; i++) {
        
                new Thread(new Runnable() {
        
                    @Override
                    public void run() {
        
                        SingletonV3 singleton1 = SingletonV3.getSingletonV3();
                        System.out.println(Thread.currentThread().getName() + "，" + singleton1);
                    }
                }).start();
            }
        }
    }

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_size_18_color_FFFFFF_t_70_g_se_x_16 1]

### 5. 静态内部类形式 ###

package com.demo.singleton.v4;
    
    /**
     * @Author: JYC
     * @Title: SingletonV4
     * @Description: TODO
     * @Date: 2022/4/20 12:08
     */
    public class SingletonV4 {
        
        private SingletonV4() {
        
            System.out.println("构造函数被初始化...");
        }
    
        public static SingletonV4 getInstance() {
        
            return SingletonV4Utils.singletonV4;
        }
    
        // 在类里面嵌套的
        private static class SingletonV4Utils {
        
            private static final SingletonV4 singletonV4 = new SingletonV4();
    
        }
    
        // 静态内部类特征：继承懒汉式和饿汉式优点，同时解决双重检验锁第一次加载慢的问题，读和写都不需要同步，效率非常高...
        public static void main(String[] args) {
        
            System.out.println("项目启动成功...");
            SingletonV4 instance1 = SingletonV4.getInstance();
            SingletonV4 instance2 = SingletonV4.getInstance();
            System.out.println(instance1 == instance2);
        }
    }

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_size_10_color_FFFFFF_t_70_g_se_x_16]

### 6. 枚举形式 ###

package com.demo.singleton.v7;
    
    /**
     * @Author: JYC
     * @Title: EnumSingleton
     * @Description: TODO
     * @Date: 2022/4/20 14:29
     */
    public enum EnumSingleton {
        
        INSTANCE;
    
        // 枚举能够绝对有效的防止实例化多次，和防止反射和序列化破击
        public void add(){
        
            System.out.println("add方法...");
        }
    }

package com.demo.singleton.v7;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.InvocationTargetException;
    
    /**
     * @Author: JYC
     * @Title: EnumSingletonTest
     * @Description: TODO
     * @Date: 2022/4/20 14:29
     */
    public class EnumSingletonTest {
        
        public static void main(String[] args) throws InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchMethodException {
        
            EnumSingleton singleton1 = EnumSingleton.INSTANCE;
            EnumSingleton singleton2 = EnumSingleton.INSTANCE;
            System.out.println(singleton1 == singleton2);
            singleton1.add();
    
            // 通过反射破坏单例
            Constructor<EnumSingleton> declaredConstructor = EnumSingleton.class.getDeclaredConstructor();
            declaredConstructor.setAccessible(true);
            EnumSingleton singleton3 = declaredConstructor.newInstance();
            System.out.println(singleton3 == singleton1);
        }
    }

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_size_20_color_FFFFFF_t_70_g_se_x_16 2]

### 7. 使用容器管理 ###

### 8. 如何防止破坏单例 ###

虽然单例通过私有构造函数，可以实现防止程序猿初始化对象，但是还可以通过反射和序列化技术破解单例。

#### 8.1 使用反射技术破解单例 ####

package com.demo.singleton.v5;
    
    /**
     * @Author: JYC
     * @Title: SingletonV5
     * @Description: TODO
     * @Date: 2022/4/20 14:47
     */
    public class SingletonV5 {
        
        private static SingletonV5 singletonV5;
        // 双重检验锁，解决懒汉式读和写都加上锁的问题，缺点：第一次创建对象可能会比较慢
        // 如何解决读和写都不加锁，还能保证唯一性线程安全问题
    
        private SingletonV5() {
        
            System.out.println("SingletonV5被初始化...");
        }
    
        /**
         * 读的不加锁，写的时候才会加锁
         */
        public static SingletonV5 getSingletonV5() {
        
    
            // 当多个线程同时在可能new对象的时候，才会加锁，保证线程安全问题
            if (singletonV5 == null) {
        
                try {
        
                    Thread.sleep(2000);  //
                } catch (Exception e) {
        
    
                }
                synchronized (SingletonV5.class) {
        
                    if (singletonV5 == null) {
         // 当前线程已经获取到锁了，再判断一下该对象是否已经初始化过，没有初始化过的创建
                        singletonV5 = new SingletonV5();
                    }
                }
            }
            return singletonV5;
        }
        // 双重检验锁的目的时什么？    解决懒汉式获取对象效率问题。
    }

package com.demo.singleton.v5;
    
    import com.demo.singleton.v3.SingletonV3;
    
    import java.lang.reflect.Constructor;
    
    /**
     * @Author: JYC
     * @Title: SingletonV5Test
     * @Description: TODO
     * @Date: 2022/4/20 14:48
     */
    public class SingletonV5Test {
        
        public static void main(String[] args) throws Exception {
        
            // 单例基本原则：保证在单个jvm中不重复创建
            SingletonV5 singleton1 = SingletonV5.getSingletonV5();
            // 如何去破解单例？  使用java的反射技术、序列化技术
            Constructor<SingletonV5> declaredConstructor = SingletonV5.class.getDeclaredConstructor();
            declaredConstructor.setAccessible(true);
            // 使用java的反射技术创建
            SingletonV5 singleton2 = declaredConstructor.newInstance();
            System.out.println(singleton1 == singleton2);
        }
    }

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

#### 8.2 如何防止被反射破解 ####

package com.demo.singleton.v5;
    
    /**
     * @Author: JYC
     * @Title: SingletonV5
     * @Description: TODO
     * @Date: 2022/4/20 14:47
     */
    public class SingletonV5 {
        
        private static SingletonV5 singletonV5;
        // 双重检验锁，解决懒汉式读和写都加上锁的问题，缺点：第一次创建对象可能会比较慢
        // 如何解决读和写都不加锁，还能保证唯一性线程安全问题
    
        private SingletonV5() throws Exception {
        
            if (singletonV5 != null) {
        
                throw new Exception("对象已经被初始化");
            }
            System.out.println("SingletonV5被初始化...");
        }
    
        /**
         * 读的不加锁，写的时候才会加锁
         */
        public static SingletonV5 getSingletonV5() throws Exception {
        
    
            // 当多个线程同时在可能new对象的时候，才会加锁，保证线程安全问题
            if (singletonV5 == null) {
        
                try {
        
                    Thread.sleep(2000);  //
                } catch (Exception e) {
        
    
                }
                synchronized (SingletonV5.class) {
        
                    if (singletonV5 == null) {
         // 当前线程已经获取到锁了，再判断一下该对象是否已经初始化过，没有初始化过的创建
                        singletonV5 = new SingletonV5();
                    }
                }
            }
            return singletonV5;
        }
        // 双重检验锁的目的时什么？    解决懒汉式获取对象效率问题。
    }

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_size_19_color_FFFFFF_t_70_g_se_x_16 1]

#### 8.3 使用序列化技术破解单例 ####

package com.demo.singleton.v6;
    
    import java.io.*;
    
    /**
     * @Author: JYC
     * @Title: SingletonV6
     * @Description: TODO
     * @Date: 2022/4/20 14:20
     */
    public class SingletonV6 implements Serializable {
        
        public static void main(String[] args) throws Exception {
        
            // 从硬盘中读取到内存——反序列化
            SingletonV6 singleton1 = SingletonV6.getSingLetonV6();
            FileOutputStream fos = new FileOutputStream("D:\\ideaCode\\demo06\\src\\main\\resources\\Singleton.obj");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(singleton1);
            oos.flush();
            oos.close();
    
            // 反序列化
            FileInputStream fis = new FileInputStream("D:\\ideaCode\\demo06\\src\\main\\resources\\Singleton.obj");
            ObjectInputStream ois = new ObjectInputStream(fis);
            SingletonV6 singleton2 = (SingletonV6) ois.readObject();
            System.out.println(singleton1 == singleton2);
        }
    
        /**
         * 饿汉式
         * 优点：先天性线程安全，当类初始化的时候，就被创建该对象。
         * 缺点：如果项目中使用过多的饿汉式会发生问题，项目在启动的时候会变得非常慢，存放在方法区占用内存比较大
         * 如果用户不使用该对象的时候，也会被提前创建好
         */
        private static SingletonV6 singLetonV6 = new SingletonV6();
    
        // 1. 单例模式是否可以让程序员初始化
        private SingletonV6() {
        
    
        }
    
        /**
         * 返回该对象的实例
         *
         * @return
         */
        public static SingletonV6 getSingLetonV6() {
        
            return singLetonV6;
        }
    }

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_size_20_color_FFFFFF_t_70_g_se_x_16 3]  
![在这里插入图片描述][5ce6fc991cd641cea2de993558ec2022.png]

#### 8.4 如何防止被序列化技术破解 ####

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

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/02b3780a083343ffb21ca91078533689.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_size_18_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/ddee5caeaf0f4ac8bda7383a08c2aac7.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_,size_18,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_size_19_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/a7f9e0e10a0c47bab7c4b46f53aa9aa8.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_,size_19,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/b6a7b8910b19406fa45b533372015642.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_size_18_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/4fabae3b09d9412982d25adc6a3360f9.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_,size_18,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_size_10_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/004d4f8446fa447bbe2c5b36b1c2d206.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_,size_10,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_size_20_color_FFFFFF_t_70_g_se_x_16 2]: https://img-blog.csdnimg.cn/4a78e102d1294501a300b91c17f3aff5.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_,size_20,color_FFFFFF,t_70,g_se,x_16
[7043576b9b3b4792b746949c4b7610e2.png]: https://img-blog.csdnimg.cn/7043576b9b3b4792b746949c4b7610e2.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_size_19_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/35e82965628f4c1da583e9ca82a7c7d0.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_,size_19,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_size_20_color_FFFFFF_t_70_g_se_x_16 3]: https://img-blog.csdnimg.cn/d7a1d6fe08f54875b5f7c795e9b4a6f4.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_,size_20,color_FFFFFF,t_70,g_se,x_16
[5ce6fc991cd641cea2de993558ec2022.png]: https://img-blog.csdnimg.cn/5ce6fc991cd641cea2de993558ec2022.png
[85952ef1b2eb4e75a9b09023efc2c6f9.png]: https://img-blog.csdnimg.cn/85952ef1b2eb4e75a9b09023efc2c6f9.png