浅谈Java设计模式之单例模式

一、设计模式的简单介绍

• 定义：一套被反复使用、多数人知晓、经过分类编目的代码设计经验的总结。
• 即设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。
• 23种设计模式（其他设计模式的基础）：
  1. 桥接模式
  2. 适配器模式
  3. 状态模式
  4. 工厂方法模式
  5. 抽象工厂模式
  6. 备忘录模式
  7. 代理模式
  8. 模板方法模式
  9. 责任链模式
  10. 观察者模式
  11. 组合模式
  12. 策略模式
  13. 建造者模式
  14. 解释器模式
  15. 享元模式
  16. 中介者模式
  17. 外观模式
  18. 单例模式
  19. 命令模式
  20. 访问者模式
  21. 迭代子模式
  22. 装饰器模式
  23. 原型模式
• 根据作用，进行类型的划分：
  1. 创建型模式：关注对象创建过程的设计模式；如工厂方法模式、建造者模式、抽象工厂模式、原型模式、单例模式；
  2. 结构型模式：关注类和对象组合的设计模式；如桥接模式、代理模式、享元模式、外观模式、装饰器模式、组合模式、适配器模式
  3. 行为型模式：关注对象的通讯过程；如备忘录模式、解释器模式、命令模式、中介者模式、观察者模式、策略模式、状态模式、模板方法模式、访问者模式、迭代子模式、责任链模式。
• 设计模式不是基于理论发明，相反，它是针对现有的一些问题、一些场景，再基于需求和场景不断地演化而形成的解决方案。简言之：设计模式是基于场景的解决方案。所以，在学习每个设计模式的时候，最好能够结合实际的场景的真实问题来理解和分析。这样，我们就能事半功倍了。
• 如果某个新场景的解决方案被认可，那我们就可以定义一个新的设计模式。

二、单例模式

• 目的：使得类的一个对象成为该类系统中的唯一实例

• 定义：一个类有且仅有一个实例，并且自行实例化向整个系统提供

• 要点：

  1. 某个类只能有一个实例；
  2. 必须自行创建实例；
  3. 必须自行向整个系统提供这个实例。

• 实现：

  1. 只提供私有的构造方法；
  2. 含有一个该类的静态私有对象；
  3. 提供一个静态的公有方法用于创建、获取静态私有对象；

• 代码实现方案：

  1. 饿汉式：对象创建过程中直接实例化；

     • 一种典型的空间换时间的操作形式：速度快、空间大。

     • 饿汉式示例代码如下：

     public class SingletenOne {
         //1. 创建类中私有构造
         private SingletenOne() {
     
         }
     
         //2. 创建该类型的私有静态实例(饿汉式)
         private static SingletenOne instance = new SingletenOne();
     
         //3. 创建公有静态方法返回静态实例对象
         public static SingletenOne getInstance() {
             return instance;
         }
     }
     

     测试代码如下：

     public class Test {
         public static void main(String[] args) {
             SingletenOne one = SingletenOne.getInstance();
             SingletenOne two = SingletenOne.getInstance();
             System.out.println(one);
             System.out.println(two);
         }
     }
     

     输出结果：

     com.singleton.SingletenOne@1540e19d
     com.singleton.SingletenOne@1540e19d

2. 懒汉式：静态公有方法中实例化。

   • 类内实例对象创建时并不直接初始化，直到第一次调用 get 方法时，才完成初始化的操作。

   • 一种时间换空间的编码形式。

   • 懒汉式示例代码如下：

   public class SingletenTwo {
       //1. 创建私有构造方法
       private SingletenTwo() {
   
       }
   
       //2. 创建静态的该类实例对象(懒汉式)
       private static SingletenTwo instance = null;
   
       //3.创建开放的静态方法提供实例对象
       public static SingletenTwo getInstance() {
           if (instance == null) {
               instance = new SingletenTwo();
           }
           return instance;
       }
   }
   

   测试类：

   import com.singleton.SingletenOne;
   import com.singleton.SingletenTwo;
   
   public class Test {
       public static void main(String[] args) {
           SingletenOne one = SingletenOne.getInstance();
           SingletenOne two = SingletenOne.getInstance();
           System.out.println(one);
           System.out.println(two);
   
           System.out.println("=======================");
   
           SingletenTwo one1 = SingletenTwo.getInstance();
           SingletenTwo one2 = SingletenTwo.getInstance();
           System.out.println(one1);
           System.out.println(one2);
       }
   }
   

   输出结果：

   com.singleton.SingletenOne@1540e19d

   com.singleton.SingletenOne@1540e19d

   =======================

   com.singleton.SingletenTwo@677327b6
   com.singleton.SingletenTwo@677327b6

3. 饿汉式 PK 懒汉式

   • 饿汉式

     （1）在类加载时就创建实例；该类的实例在第一次加载的时候速度快、是一种典型的以空间换时间的操作方式；

     （2）饿汉式线程安全

   • 懒汉式：

     （1）第一次使用时进行实例化；该类的实例在第一次加载的时候速度慢，在该类创建后如果一直不使用该类的实例，也不会造成内存空间的浪费，所以他是一种时间换空间的操作方式；

     （2）懒汉式存在线程风险

     • 解决方案：同步锁、双重校验锁、静态内部类、枚举

• 优点：

  1. 在内存中只有一个对象，节省内存空间；

  2. 避免频繁地创建销毁对象，提高性能；

  3. 避免对共享资源的多重占用。

• 缺点：

  1. 扩展比较困难；
  2. 如果实例化后的对象长期不利用，系统将默认对垃圾进行回收，造成对象状态丢失。

• 使用场景（具体场景具体分析）：

  1. 创建对象时占用资源过多，但同时又需要用到该类对象；
  2. 对系统内资源要求统一读写，如读写配置信息；
  3. 当多个实例存在可能引起程序逻辑错误，如号码生成器