GOF23设计模式（创建型模式）单例模式

ゞ浴缸里的玫瑰 2023-02-17 03:17 13阅读 0赞

# 目录： #

一：单例模式的核心作用、常见应用场景

二：五种单例模式及其实现

三：关于反射和反序列化破解单例模式的漏洞，以及相应的解决方案

四：测试五种单例模式的效率

--------------------

# 一：核心作用及常见应用场景： #

**核心作用：**保证一个类只有一个实例对象，并且提供一个访问该实例对象的全局访问点（获取实例对象的方法），通过该访问点获得对象唯一

**常见应用场景：**

<table> 
 <tbody> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:.6673in;"> 1 </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;"> Windows的 Task Manager（任务管理器）就是很典型的单例模式（无论打开多少次任务管理器，只会出现一个任务管理器） </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:.6673in;"> 2 </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;"> windows的 Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站直维护着仅有的一个实例 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:.6673in;"> 3 </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;"> 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，每次new一个对象去读取。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:.6673in;"> 4 </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;"> 网站的计数器，一般也是采用单例模式实现，否则难以同步。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:.6673in;"> 5 </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;"> 应用程序的日志应用，一般都何用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:.6673in;"> 6 </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;"> 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:.6673in;"> 7 </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;"> 操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:.6673in;"> 8 </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;"> Application也是单例的典型应用（ Servlet编程中会涉及到） </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:.6673in;"> 9 </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;"> 在 Spring中，每个Bean默认就是单例的，这样做的优点是 Spring容器可以管理 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:.6673in;"> 10 </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;"> 在 servlet编程中，每个Sere也是单例 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:.6673in;"> 11 </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;"> 在 spring MVC框架/ struts1框架中，控制器对象也是单例 </td> 
 </tr> 
 </tbody> 
</table>

--------------------

# 二：五种单例模式及其实现方式~~(附代码) #

<table> 
 <tbody> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:.6673in;"> 主要 </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;"> 饿汉式（线程安全，调用效率高。但是，不能延时加载。） 懒汉式（线程安全，调用效率不高。但是，可以延时加载。） </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:.6673in;"> 其他 </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;"> 双重检测锁式（由于JVM底层內部模型原因，偶尔会出问题。不建议使用） 静态内部类式（线程安全，调用效率高。但是，可以延时加载） 枚举单例（线程安全，调用效率高，不能延时加载） </td> 
 </tr> 
 </tbody> 
</table>

### **1. 饿汉式：** ###

饿汉式单例模式代码中， static变量会在类装载时初始化，此时也不会涉及多个线程对象访问该对象的问题。虛拟机保证只会装载一次该类，肯定不会发生并发访问的问题。因此，可以省略synchronized关键字。

问题：如果只是加载本类，而不是要调用 getinstance()，甚至永远没有调用，则会造成资源浪费！

package 设计模式;
    
    /**
     * 测试饿汉式单例模式
     * 线程安全
     * 立即加载
     */
    public class Singleton1 {
        //类初始化时立即加载（没有延时加载的优势），加载类时，天然是线程安全的
        public static Singleton1 instance = new Singleton1();
    
        //构造器私有
        private Singleton1() {}
    
        //方法没有同步，调用效率高
        public static Singleton1 getInstance() {
            return instance;
        }
    
        public static void main(String[] args) {
            Singleton1 singleton1 = Singleton1.getInstance();
            Singleton1 singleton2 = singleton1.getInstance();
            System.out.println(singleton1 == singleton2);//true
        }
    }

### 2.  懒汉式 ###

要点: lazy load 延迟加载，只有真正用的时候才加载！

问题: 资源利用率高了。但是，每次调用 getinstanceO方法都要同步，并发效率较低。

package 设计模式;
    
    /**
     * 测试懒汉式单例模式
     * 线程安全
     * 延时加载
     */
    public class Singleton2 {
        //类初始化时，不初始化这个对象（延时加载，真正用的时候才加载）
        public static Singleton2 instance;
    
        //构造器私有
        private Singleton2() {}
    
        //方法同步，调用效率低
        public static Singleton2 getInstance() {
            if (instance == null)
                instance = new Singleton2();
            return instance;
        }
    
        public static void main(String[] args) {
            Singleton2 singleton1 = Singleton2.getInstance();
            Singleton2 singleton2 = singleton1.getInstance();
            System.out.println(singleton1 == singleton2);//true
        }
    }

### 3. **双重检测锁式：（不建议使用！！）** ###

看看代码就ok~

package 设计模式;
    
    /**
     * 测试双重检查锁单例模式
     * 不建议使用
     */
    public class Singleton3 {
        //类初始化时，不初始化这个对象（延时加载，真正用的时候才加载）
        public static Singleton3 instance = null;
    
        //构造器私有
        private Singleton3() {}
    
        //方法同步，调用效率低
        public static Singleton3 getInstance() {
            if (instance == null) {
                Singleton3 sc;
                synchronized (Singleton3.class) {
                    sc = instance;
                    if (sc == null) {
                        synchronized (Singleton3.class) {
                            if (sc == null)
                                sc = new Singleton3();
                        }
                        instance = sc;
                    }
                }
            }
            return instance;
        }
    
        public static void main(String[] args) {
            Singleton3 singleton1 = Singleton3.getInstance();
            Singleton3 singleton2 = singleton1.getInstance();
            System.out.println(singleton1 == singleton2);//true
        }
    }

### 4. **静态内部类式：** ###

要点：

1.  外部类没有 static属性，则不会像饿汉式那样立即加载对象
2.  只有真正调用 getinstance()，才会加载静态内部类。加载类时是线程安全的。 Instance是 static final类型，保证了内存中只有这样一个实例存在，而且只能被赋值一次，从而保证了线程安全性。
3.  兼备了并发高效调用和延迟加载的优势！

package 设计模式;
    
    /**
     * 测试静态内部类单例模式
     * 线程安全，调用效率高，并且实现延迟加载
     */
    public class Singleton4 {
        //静态内部类
        private static class SingletonClassInstance {
            private static final Singleton4 instance = new Singleton4();
        }
    
        //构造器私有
        private Singleton4() {}
    
        public static Singleton4 getInstance() {
            return SingletonClassInstance.instance;
        }
    
        public static void main(String[] args) {
            Singleton4 singleton1 = Singleton4.getInstance();
            Singleton4 singleton2 = singleton1.getInstance();
            System.out.println(singleton1 == singleton2);//true
        }
    }

### 5. 枚举单例： ###

优点: 实现简单,枚举本身就是单例模式。由JVM从根本上提供保障！避免通过反射和反序列化的漏洞！

缺点:无延迟加载

package 设计模式;
    
    /**
     * 测试枚举单例模式
     * 实现简单,枚举本身就是单例模式。由JVM从根本上提供保障！避免通过反射和反序列化的漏洞！
     * 无延时加载
     */
    public enum Singleton5 {
        //这个枚举元素，本身就是单例模式
        INSTANCE;
    
        //添加自己需要的操作
        public void singletonOperation() {
    
        }
    
        public static void main(String[] args) {
            Singleton5 singleton1 = Singleton5.INSTANCE;
            Singleton5 singleton2 = singleton1.INSTANCE;
            System.out.println(singleton1 == singleton2);//true
        }
    }

--------------------

# 三：**反射和反序列化漏洞及其解决方案** #

--------------------

## 1.反射可以破解上面几种实现方式~（不包含枚举式） ##

### 示例：通过反射破解静态内部类的单例模式(联系上方静态内部类实现单例模式的代码) ###

package 设计模式;
    
    import java.lang.reflect.Constructor;
    
    /**
     * 避免通过反射破解静态内部类单例模式
     */
    public class singleProblem1 {
        public static void main(String[] args) throws Exception {
            Singleton4 s1 = Singleton4.getInstance();
            Singleton4 s2 = Singleton4.getInstance();
            System.out.println(s1);
            System.out.println(s2);
            //通过反射直接调用私有构造器
            Class c = Class.forName("设计模式.Singleton4");
            System.out.println(c);
            Constructor constructor = c.getDeclaredConstructor(null);
            constructor.setAccessible(true);
            Singleton4 s3 = (Singleton4) constructor.newInstance();
            Singleton4 s4 = (Singleton4) constructor.newInstance();
            System.out.println(s3);
            System.out.println(s4);
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTczNDA0_size_16_color_FFFFFF_t_70][]

根据结果，发现产生了两个新对象，我们的解决方案就是 **在私有构造器中手动抛出异常控制，在私有构造器内加入以下代码**

### **解决方法：**可以在私有构造器中手动抛出异常控制 ###

//构造器私有
        private Singleton4() {
            if (getInstance() != null)
                throw new RuntimeException();
        }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTczNDA0_size_16_color_FFFFFF_t_70 1][]

根据实验结果发现，已经无法通过反射用私有构造器创建新的对象！！

解决成功！！！

## 2.反序列化可以破解上面几种（不包含枚举式）实现方式！ ##

### 示例：通过反序列化破解静态内部类的单例模式(联系上方静态内部类实现单例模式的代码) ###

package 设计模式;
    
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    
    /**
     * 避免通过反射破解静态内部类单例模式
     */
    public class singleProblem1 {
        public static void main(String[] args) throws Exception {
            Singleton4 s1 = Singleton4.getInstance();
            Singleton4 s2 = Singleton4.getInstance();
            System.out.println(s1);
            System.out.println(s2);
            //通过反序列化的的方式构造多个对象
            //序列化
            ObjectOutputStream out = new ObjectOutputStream(
                    new FileOutputStream("D:/学习/IDEA project/project/src/设计模式/a.txt"));
            out.writeObject(s1);
            out.close();
            //反序列化
            ObjectInputStream in = new ObjectInputStream(
               new FileInputStream("D:/学习/IDEA project/project/src/设计模式/a.txt"));
            Singleton4 s3 = (Singleton4) in.readObject();
            System.out.println(s3);//如果没有readResolve方法则会构造出一个新对象，破解了单例
    
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTczNDA0_size_16_color_FFFFFF_t_70 2][]

根据结果，发现产生了一个新对象，我们的解决方案就是在上方静态内部类实现单例的代码中加入readResolve函数

###   **解决方法：**可以通过定义readResolve()防止获得不同对象。 ###

###   反序列化时，如果对象所在类定义了readResolve(),(实际是一种回调），定义返回哪个对象 ###

//为了防止反序列化破解，添加此方法
        //如果定义了readResolve方法，则直接返回此方法指定的对象，而不需要再单独创建对象
        private Object readResolve() {
            return getInstance();
        }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTczNDA0_size_16_color_FFFFFF_t_70 3][]

根据新的实验结果，我们发现新创建出来的对象与通过单例模式创建出的对象相同，即解决成功！！

--------------------

# 四：测试单例模式的效率  #

通过一下代码可以测试上述五种方法效率，一下为测试Singleton1，即饿汉式实现单例的时间！！！！

package 设计模式;
 
 import java.util.concurrent.CountDownLatch;
 
 public class testtime {
 public static void main(String[] args) throws InterruptedException {
 long start = System.currentTimeMillis();
 int threadNum = 10;
 CountDownLatch countDownLatch = new CountDownLatch(threadNum);
 for (int i = 0; i < 10; i++) {
 new Thread(new Runnable() {
 @Override
 public void run() {
 for (int j = 0; j < 100000; j++)
 Singleton1.getInstance();
 countDownLatch.countDown();
 }
 }).start();
 }
 countDownLatch.await();//main线程阻塞，知道计数器变为0，才会继续往下执行
 long end = System.currentTimeMillis();
 System.out.println("总耗时:" + (end - start));
 }
 }

### 其中，很重要的一个类 ###

### **CountDownLatch** ###

同步辅助类，在完成组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待

<table> 
 <tbody> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:1.5888in;"> countDown() </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:5.8388in;"> 当前线程调此方法，则计数减1（建议放在 finally里执行） </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:1.5694in;"> await() </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:5.7888in;"> 调用此方法会一直阻塞当前线程，直到计时器的值为0 </td> 
 </tr> 
 </tbody> 
</table>

在此方法中，在主线程执行后，启动了十个线程 ，其中通过**CountDownLatch类** 实例化出来的**countdownlatch**相当于一个计数器，初始化为10，每当一个线程执行完后减一，一直阻塞着主线程，直到这十个线程都执行完毕，则主线程停止阻塞，记录最后的时间end，则end-start即为执行这是个线程所需要的时间！

--------------------

### THE END ###

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTczNDA0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200611190052389.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTczNDA0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTczNDA0_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2020061119033377.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTczNDA0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTczNDA0_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200611190819482.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTczNDA0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTczNDA0_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200611191234199.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTczNDA0,size_16,color_FFFFFF,t_70