设计模式(持续更新)之一：单例模式

曾经终败给现在 2023-10-04 19:24 10阅读 0赞

**目录**

一，设计模式简介

二，设计模式类型

三，设计模式的六大原则

四，单例模式

五，代码实现

5.1、懒汉式，线程不安全

5.2、懒汉式，线程安全

5.3、饿汉式

5.4、双检锁/双重校验锁（DCL，即 double-checked locking）

5.5、登记式/静态内部类

5.6、枚举

六，总结

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

## 一，设计模式简介 ##

设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理地运用设计模式可以完美地解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式都描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是设计模式能被广泛应用的原因。

## 二，设计模式类型 ##

根据设计模式的参考书 **Design Patterns - Elements of Reusable Object-Oriented Software（中文译名：设计模式 - 可复用的面向对象软件元素）** 中所提到的，总共有 23 种设计模式。这些模式可以分为三大类：创建型模式（Creational Patterns）、结构型模式（Structural Patterns）、行为型模式（Behavioral Patterns）。另外，一些由Sun Java Center鉴定的设计模式也会纳入设计模式讨论范围。大体分布如下：

<table> 
 <tbody> 
  <tr> 
   <th>序号</th> 
   <th>模式 &amp; 描述</th> 
   <th>包括</th> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td><strong>创建型模式</strong><br> 这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。</td> 
   <td> 
    <ul> 
     <li>工厂模式（Factory Pattern）</li> 
     <li>抽象工厂模式（Abstract Factory Pattern）</li> 
     <li>单例模式（Singleton Pattern）</li> 
     <li>建造者模式（Builder Pattern）</li> 
     <li>原型模式（Prototype Pattern）</li> 
    </ul></td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><strong>结构型模式</strong><br> 这些设计模式关注类和对象的组合。继承的概念被用来组合接口和定义组合对象获得新功能的方式。</td> 
   <td> 
    <ul> 
     <li>适配器模式（Adapter Pattern）</li> 
     <li>桥接模式（Bridge Pattern）</li> 
     <li>过滤器模式（Filter、Criteria Pattern）</li> 
     <li>组合模式（Composite Pattern）</li> 
     <li>装饰器模式（Decorator Pattern）</li> 
     <li>外观模式（Facade Pattern）</li> 
     <li>享元模式（Flyweight Pattern）</li> 
     <li>代理模式（Proxy Pattern）</li> 
    </ul></td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td><strong>行为型模式</strong><br> 这些设计模式特别关注对象之间的通信。</td> 
   <td> 
    <ul> 
     <li>责任链模式（Chain of Responsibility Pattern）</li> 
     <li>命令模式（Command Pattern）</li> 
     <li>解释器模式（Interpreter Pattern）</li> 
     <li>迭代器模式（Iterator Pattern）</li> 
     <li>中介者模式（Mediator Pattern）</li> 
     <li>备忘录模式（Memento Pattern）</li> 
     <li>观察者模式（Observer Pattern）</li> 
     <li>状态模式（State Pattern）</li> 
     <li>空对象模式（Null Object Pattern）</li> 
     <li>策略模式（Strategy Pattern）</li> 
     <li>模板模式（Template Pattern）</li> 
     <li>访问者模式（Visitor Pattern）</li> 
    </ul></td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td><strong>J2EE 模式</strong><br> 这些设计模式特别关注表示层。这些模式是由 Sun Java Center 鉴定的。</td> 
   <td> 
    <ul> 
     <li>MVC 模式（MVC Pattern）</li> 
     <li>业务代表模式（Business Delegate Pattern）</li> 
     <li>组合实体模式（Composite Entity Pattern）</li> 
     <li>数据访问对象模式（Data Access Object Pattern）</li> 
     <li>前端控制器模式（Front Controller Pattern）</li> 
     <li>拦截过滤器模式（Intercepting Filter Pattern）</li> 
     <li>服务定位器模式（Service Locator Pattern）</li> 
     <li>传输对象模式（Transfer Object Pattern）</li> 
    </ul></td> 
  </tr> 
 </tbody> 
</table>

## 三，设计模式的六大原则 ##

**1、开闭原则（Open Close Principle）**

开闭原则的意思是：**对扩展开放，对修改关闭**。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。

**2、里氏代换原则（Liskov Substitution Principle）**

里氏代换原则是面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。LSP 是继承复用的基石，只有当派生类可以替换掉基类，且软件单位的功能不受到影响时，基类才能真正被复用，而派生类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

**3、依赖倒转原则（Dependence Inversion Principle）**

这个原则是开闭原则的基础，具体内容：针对接口编程，依赖于抽象而不依赖于具体。

**4、接口隔离原则（Interface Segregation Principle）**

这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。它还有另外一个意思是：降低类之间的耦合度。由此可见，其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。

**5、迪米特法则，又称最少知道原则（Demeter Principle）**

最少知道原则是指：一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。

**6、合成复用原则（Composite Reuse Principle）**

合成复用原则是指：尽量使用合成/聚合的方式，而不是使用继承。

## 四，单例模式 ##

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

**注意：**

*  1、单例类只能有一个实例。
 *  2、单例类必须自己创建自己的唯一实例。
 *  3、单例类必须给所有其他对象提供这一实例。

**意图：**保证一个类仅有一个实例，并提供一个访问它的全局访问点。

**主要解决：**一个全局使用的类频繁地创建与销毁。

**何时使用：**当您想控制实例数目，节省系统资源的时候。

**如何解决：**判断系统是否已经有这个单例，如果有则返回，如果没有则创建。

**关键代码：将构造函数和本身的静态实例私有化**。

**使用场景：**

*  1、要求生产唯一序列号。
 *  2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
 *  3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

## 五，代码实现 ##

单例模式有多种实现方式：

#### **5.1、懒汉式，线程不安全** ####

**是否 Lazy 初始化：**是

**是否多线程安全：**否

**实现难度：**易

**描述：**这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。

public class SingletonTest1 {
        /**
        私有化静态实例
         */
        private static SingletonTest1 instance;
    
        /**
         * 私有化构造函数
         */
        private SingletonTest1 (){}
    
        /**
         * 获取实例对象
         * @return 实例对象
         */
        public static SingletonTest1 getInstance() {
            if (instance == null) {
                instance = new SingletonTest1();
            }
            return instance;
        }
    }

#### 5.2、懒汉式，线程安全 ####

**是否 Lazy 初始化：**是

**是否多线程安全：**是

**实现难度：**易

**描述：**这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。  
优点：第一次调用才初始化，避免内存浪费。  
缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。  
getInstance() 的性能对应用程序不是很关键（该方法使用不太频繁）。

public class SingletonTest2 {
        private static SingletonTest2 instance;
        private SingletonTest2 (){}
        public static synchronized SingletonTest2 getInstance() {
            if (instance == null) {
                instance = new SingletonTest2();
            }
            return instance;
        }
    }

#### 5.3、饿汉式 ####

**是否 Lazy 初始化：**否

**是否多线程安全：**是

**实现难度：**易

**描述：**这种方式比较常用，但容易产生垃圾对象。  
优点：没有加锁，执行效率会提高。  
缺点：类加载时就初始化，浪费内存。  
它基于 classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。

public class SingletonTest3 {
        private static SingletonTest3 instance = new SingletonTest3();
        private SingletonTest3 (){}
        public static SingletonTest3 getInstance() {
            return instance;
        }
    }

#### 5.4、双检锁/双重校验锁（DCL，即 double-checked locking） ####

**JDK 版本：**JDK1.5 起

**是否 Lazy 初始化：**是

**是否多线程安全：**是

**实现难度：**较复杂

**描述：**这种方式采用双锁机制，安全且在多线程情况下能保持高性能。  
getInstance() 的性能对应用程序很关键。

public class SingletonTest4 {
        private volatile static SingletonTest4 singleton;
        private SingletonTest4 (){}
        public static SingletonTest4 getSingleton() {
            if (singleton == null) {
                synchronized (SingletonTest4.class) {
                    if (singleton == null) {
                        singleton = new SingletonTest4();
                    }
                }
            }
            return singleton;
        }
    }

#### 5.5、登记式/静态内部类 ####

**是否 Lazy 初始化：**是

**是否多线程安全：**是

**实现难度：**一般

**描述：**这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。  
这种方式同样利用了 classloader 机制来保证初始化 instance 时只有一个线程，它跟第 3 种方式不同的是：第 3 种方式只要 Singleton 类被装载了，那么 instance 就会被实例化（没有达到 lazy loading 效果），而这种方式是 Singleton 类被装载了，instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance。想象一下，如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面，又不希望在 Singleton 类加载时就实例化，因为不能确保 Singleton 类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance 显然是不合适的。这个时候，这种方式相比第 3 种方式就显得很合理。

public class SingletonTest5 {
        private static class SingletonHolder {
            private static final SingletonTest5 INSTANCE = new SingletonTest5();
        }
        private SingletonTest5 (){}
        public static final SingletonTest5 getInstance() {
            return SingletonHolder.INSTANCE;
        }
    }

#### 5.6、枚举 ####

**JDK 版本：**JDK1.5 起

**是否 Lazy 初始化：**否

**是否多线程安全：**是

**实现难度：**易

**描述：**这种实现方式是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。不能通过 reflection attack 来调用私有构造方法。

public enum  SingletonTest6{
        INSTANCE;
        public void method(){
        }
    }

一般情况下，不建议使用第 1 种和第 2 种懒汉方式，建议使用第 3 种饿汉方式。只有在要明确实现 lazy loading 效果时，才会使用第 5 种登记方式。如果涉及到反序列化创建对象时，可以尝试使用第 6 种枚举方式。如果有其他特殊的需求，可以考虑使用第 4 种双检锁方式。

## 六，总结 ##

单例模式一般用于经常性的需要创建和销毁类，如果频繁的去通过实例化去调用相关类的方法，这样无疑是对系统资源的一种浪费。因此单例模式在创建时首先就将类的构造方法私有化了，这样避免了过多的去实例化类对象，例外通过静态实例的形式，根据系统条件需求去创建类，做到“按需取用”。日常使用的框架源码中我们也能看到单例模式的身影，在Spring中依赖注入Bean的形式默认就是单例模式...

另外，单例模式的优缺点如下：

**优点：**

*  1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例。。
 *  2、避免对资源的多重占用（比如写文件操作）。

**缺点：**没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

相信合理地使用单例模式，一定能大大提高我们的开发质量。

文章绝大部分取自[菜鸟教程][Link 1]，仅作为个人笔记之用，后续在学习过程中会慢慢总结一些其他的设计模式部分……

[Link 1]: https://www.runoob.com/