Carson带你学设计模式：单例模式（Singleton）

今天Carson来全面总结最常用的设计模式 - 单例模式。

Carson带你学设计模式系列文章
Carson带你学设计模式：这是一份全面 & 详细的设计模式学习指南
Carson带你学设计模式：单例模式（Singleton）
Carson带你学设计模式：简单工厂模式（SimpleFactoryPattern）
Carson带你学设计模式：工厂方法模式（Factory Method）
Carson带你学设计模式：抽象工厂模式（Abstract Factory）
Carson带你学设计模式：建造者模式（Builder Pattern）
Carson带你学设计模式：适配器模式（Adapter Pattern）
Carson带你学设计模式：外观模式（Facade Pattern）
Carson带你学设计模式：静态代理模式（Proxy Pattern）
Carson带你学设计模式：动态代理模式（Proxy Pattern）
Carson带你学设计模式：模板方法模式（Template Method）
Carson带你学设计模式：策略模式（Strategy Pattern）
Carson带你学设计模式：观察者模式（Observer）

• 背景：小成有一个塑料生产厂，但里面只有一个仓库。
• 目的：想用代码来实现仓库的管理
• 现有做法： 建立仓库类和工人类
  

  其中，仓库类里的quantity=商品数量；工人类里有搬运方法MoveIn(int i)和MoveOut(int i)。

• 出现的问题：通过测试发现，每次工人搬运操作都会新建一个仓库，就是货物都不是放在同一仓库，这是怎么回事呢？（看下面代码）

package scut.designmodel.SingletonPattern;   //仓库类 class StoreHouse {     private int quantity = 100;      public void setQuantity(int quantity) {         this.quantity = quantity;     }      public int getQuantity() {         return quantity;     } }  //搬货工人类 class Carrier{     public StoreHouse mStoreHouse;     public Carrier(StoreHouse storeHouse){         mStoreHouse = storeHouse;     }     //搬货进仓库     public void MoveIn(int i){         mStoreHouse.setQuantity(mStoreHouse.getQuantity()+i);     }     //搬货出仓库     public void MoveOut(int i){         mStoreHouse.setQuantity(mStoreHouse.getQuantity()-i);     } }  //工人搬运测试 public class SinglePattern {     public static void main(String[] args){         StoreHouse mStoreHouse1 = new StoreHouse();         StoreHouse mStoreHouse2 = new StoreHouse();         Carrier Carrier1 = new Carrier(mStoreHouse1);         Carrier Carrier2 = new Carrier(mStoreHouse2);          System.out.println("两个是不是同一个？");          if(mStoreHouse1.equals(mStoreHouse2)){//这里用equals而不是用 == 符号，因为 == 符号只是比较两个对象的地址             System.out.println("是同一个");         }else {             System.out.println("不是同一个");         }         //搬运工搬完货物之后出来汇报仓库商品数量         Carrier1.MoveIn(30);         System.out.println("仓库商品余量："+Carrier1.mStoreHouse.getQuantity());         Carrier2.MoveOut(50);         System.out.println("仓库商品余量："+Carrier2.mStoreHouse.getQuantity());     } }

结果：

两个是不是同一个？ 不是同一个 仓库商品余量：130 仓库商品余量：50

2.1 模式说明

实现1个类只有1个实例化对象 & 提供一个全局访问点

2.2 作用（解决的问题）

保证1个类只有1个对象，降低对象之间的耦合度

从上面可看出：工人类操作的明显不是同一个仓库实例，而全部工人希望操作的是同一个仓库实例，即只有1个实例

2.3 工作原理

在Java中，我们通过使用对象（类实例化后）来操作这些类，类实例化是通过它的构造方法进行的，要是想实现一个类只有一个实例化对象，就要对类的构造方法下功夫：

单例模式的一般实现：（含使用步骤）

 public class Singleton { //1. 创建私有变量 ourInstance（用以记录 Singleton 的唯一实例） //2. 内部进行实例化     private static Singleton ourInstance  = new  Singleton();  //3. 把类的构造方法私有化，不让外部调用构造方法实例化     private Singleton() {     } //4. 定义公有方法提供该类的全局唯一访问点 //5. 外部通过调用getInstance()方法来返回唯一的实例     public static  Singleton newInstance() {         return ourInstance;     } }

好了，单例模式的介绍和原理应该了解了吧？那么我们现在来解决上面小成出现的“仓库不是一个”的问题吧！

小成使用单例模式改善上面例子的代码：

package scut.designmodel.SingletonPattern;  import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock;  //单例仓库类 class StoreHouse {      //仓库商品数量     private int quantity = 100;     //自己在内部实例化     private static StoreHouse ourInstance  = new StoreHouse();;     //让外部通过调用getInstance()方法来返回唯一的实例。     public static StoreHouse getInstance() {         return ourInstance;     }      //封闭构造函数     private StoreHouse() {     }      public void setQuantity(int quantity) {         this.quantity = quantity;     }      public int getQuantity() {         return quantity;     } }   //搬货工人类 class Carrier{     public StoreHouse mStoreHouse;     public Carrier(StoreHouse storeHouse){         mStoreHouse = storeHouse;     }     //搬货进仓库     public void MoveIn(int i){         mStoreHouse.setQuantity(mStoreHouse.getQuantity()+i);     }     //搬货出仓库     public void MoveOut(int i){         mStoreHouse.setQuantity(mStoreHouse.getQuantity()-i);     } }  //工人搬运测试 public class SinglePattern {     public static void main(String[] args){         StoreHouse mStoreHouse1 = StoreHouse.getInstance();         StoreHouse mStoreHouse2 = StoreHouse.getInstance();         Carrier Carrier1 = new Carrier(mStoreHouse1);         Carrier Carrier2 = new Carrier(mStoreHouse2);          System.out.println("两个是不是同一个？");          if(mStoreHouse1.equals(mStoreHouse2)){             System.out.println("是同一个");         }else {             System.out.println("不是同一个");         }         //搬运工搬完货物之后出来汇报仓库商品数量         Carrier1.MoveIn(30);         System.out.println("仓库商品余量："+Carrier1.mStoreHouse.getQuantity());         Carrier2.MoveOut(50);         System.out.println("仓库商品余量："+Carrier2.mStoreHouse.getQuantity());     } }

结果：

两个是不是同一个？ 是同一个 仓库商品余量：130 仓库商品余量：80

从结果分析，使用了单例模式后，仓库类就只有一个仓库实例了，再也不用担心搬运工人进错仓库了！！！

4.1 优点

• 提供了对唯一实例的受控访问；
• 由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能；
• 可以根据实际情况需要，在单例模式的基础上扩展做出双例模式，多例模式；

4.2 缺点

1. 单例类的职责过重，里面的代码可能会过于复杂，在一定程度上违背了“单一职责原则”。
2. 如果实例化的对象长时间不被利用，会被系统认为是垃圾而被回收，这将导致对象状态的丢失。

• 单例模式的实现方式有多种，根据需求场景，可分为2大类、6种实现方式。具体如下：

• 下面，我将详细介绍每种单例模式的实现方式

a. 初始化单例类时 即 创建单例

1. 饿汉式

这是 最简单的单例实现方式

• 原理
  依赖JVM类加载机制，保证单例只会被创建1次，即线程安全

1. JVM在类的初始化阶段(即 在Class被加载后、被线程使用前)，会执行类的初始化
2. 在执行类的初始化期间，JVM会去获取一个锁。这个锁可以同步多个线程对同一个类的初始化

• 具体实现

class Singleton {      // 1. 加载该类时，单例就会自动被创建     private static  Singleton ourInstance  = new  Singleton();          // 2. 构造函数 设置为 私有权限     // 原因：禁止他人创建实例      private Singleton() {     }          // 3. 通过调用静态方法获得创建的单例     public static  Singleton newInstance() {         return ourInstance;     } }

• 应用场景
  除了初始化单例类时 即 创建单例外，继续延伸出来的是：单例对象 要求初始化速度快 & 占用内存小

2. 枚举类型

• 原理
  根据枚举类型的下述特点，满足单例模式所需的创建单例、线程安全、实现简洁的需求

• 实现方式

public enum Singleton{      //定义1个枚举的元素，即为单例类的1个实例     INSTANCE;      // 隐藏了1个空的、私有的 构造方法     // private Singleton () {}  }  // 获取单例的方式： Singleton singleton = Singleton.INSTANCE;

• 注：这是最简洁、易用 的单例实现方式，借用《Effective Java》的话：

单元素的枚举类型已经成为实现Singleton的最佳方法

b. 按需、延迟创建单例

1. 懒汉式（基础实现）

• 原理

与 饿汉式 最大的区别是：单例创建的时机

• 饿汉式：单例创建时机不可控，即类加载时自动创建 单例
• 懒汉式：单例创建时机可控，即有需要时，才手动创建 单例

• 具体实现

class Singleton {     // 1. 类加载时，先不自动创建单例    //  即，将单例的引用先赋值为 Null     private static  Singleton ourInstance  = null；      // 2. 构造函数 设置为 私有权限     // 原因：禁止他人创建实例      private Singleton() {     }          // 3. 需要时才手动调用 newInstance（） 创建 单例        public static  Singleton newInstance() {     // 先判断单例是否为空，以避免重复创建     if( ourInstance == null){         ourInstance = new Singleton();         }         return ourInstance;     } }

• 缺点
  基础实现的懒汉式是线程不安全的，具体原因如下

• 下面，将对懒汉式 进行优化，使得适合在多线程环境下运行

2. 同步锁（懒汉式的改进）

• 原理
  使用同步锁synchronized锁住 创建单例的方法 ，防止多个线程同时调用，从而避免造成单例被多次创建

1. 即，getInstance（）方法块只能运行在1个线程中
2. 若该段代码已在1个线程中运行，另外1个线程试图运行该块代码，则会被阻塞而一直等待
3. 而在这个线程安全的方法里我们实现了单例的创建，保证了多线程模式下 单例对象的唯一性

• 具体实现

// 写法1 class Singleton {     // 1. 类加载时，先不自动创建单例     //  即，将单例的引用先赋值为 Null     private static  Singleton ourInstance  = null；          // 2. 构造函数 设置为 私有权限     // 原因：禁止他人创建实例      private Singleton() {     }      // 3. 加入同步锁 public static synchronized Singleton getInstance(){         // 先判断单例是否为空，以避免重复创建         if ( ourInstance == null )             ourInstance = new Singleton();         return ourInstance;     } }   // 写法2 // 该写法的作用与上述写法作用相同，只是写法有所区别 class Singleton{       private static Singleton instance = null;      private Singleton(){ }      public static Singleton getInstance(){         // 加入同步锁         synchronized(Singleton.class) {             if (instance == null)                 instance = new Singleton();         }         return instance;     } }

• 缺点
  每次访问都要进行线程同步（即 调用synchronized锁)，造成过多的同步开销（加锁 = 耗时、耗能）

实际上只需在第1次调用该方法时才需要同步，一旦单例创建成功后，就没必要进行同步

3. 双重校验锁（懒汉式的改进）

• 原理
  在同步锁的基础上，添加1层if判断：若单例已创建，则不需再执行加锁操作就可获取实例，从而提高性能

• 具体实现

class Singleton {     private static  Singleton ourInstance  = null；      private Singleton() {     }          public static  Singleton newInstance() {      // 加入双重校验锁     // 校验锁1：第1个if     if( ourInstance == null){  // ①      synchronized (Singleton.class){ // ②       // 校验锁2：第2个 if       if( ourInstance == null){           ourInstance = new Singleton();           }       }   }         return ourInstance;    } }  // 说明 // 校验锁1：第1个if // 作用：若单例已创建，则直接返回已创建的单例，无需再执行加锁操作 // 即直接跳到执行 return ourInstance  // 校验锁2：第2个 if  // 作用：防止多次创建单例问题 // 原理   // 1. 线程A调用newInstance()，当运行到②位置时，此时线程B也调用了newInstance()   // 2. 因线程A并没有执行instance = new Singleton();，此时instance仍为空，因此线程B能突破第1层 if 判断，运行到①位置等待synchronized中的A线程执行完毕   // 3. 当线程A释放同步锁时，单例已创建，即instance已非空   // 4. 此时线程B 从①开始执行到位置②。此时第2层 if 判断 = 为空（单例已创建），因此也不会创建多余的实例

• 缺点
  实现复杂 = 多种判断，易出错

4. 静态内部类

• 原理
  根据静态内部类 的特性，同时解决了按需加载、线程安全的问题，同时实现简洁

1. 在静态内部类里创建单例，在装载该内部类时才会去创建单例
2. 线程安全：类是由JVM加载，而JVM只会加载1遍，保证只有1个单例

• 具体实现

class Singleton {          // 1. 创建静态内部类     private static class Singleton2 {        // 在静态内部类里创建单例       private static  Singleton ourInstance  = new Singleton()；     }      // 私有构造函数     private Singleton() {     }          // 延迟加载、按需创建     public static  Singleton newInstance() {         return Singleton2.ourInstance;     }  }  // 调用过程说明：       // 1. 外部调用类的newInstance()        // 2. 自动调用Singleton2.ourInstance        // 2.1 此时单例类Singleton2得到初始化        // 2.2 而该类在装载 & 被初始化时，会初始化它的静态域，从而创建单例；        // 2.3 由于是静态域，因此只会JVM只会加载1遍，Java虚拟机保证了线程安全性       // 3. 最终只创建1个单例

• 本文主要对单例模式 进行了全面介绍，包括原理 & 实现方式
• 对于实现方式，此处作出总结

博客链接：https://carsonho.blog.csdn.net/