23种设计模式--单例模式

1：java面向对象23种设计模式

---

• 有的时候就会在像一个这么简单的功能用设计模式反而复杂起来因为设计模式设计之初就是站在软件可持续迭代的、整个软件架构角度去想问题。而不是去实现某个功能的角度去想问题

• 设计模式的目的：

  1. 使程序具有低耦合、高内聚的特性
  2. 代码重用性
  3. 可读性
  4. 可靠性
  5. 可扩展性

• 设计模式不是代码是某类问题的通用解决方案

• 设计模式的分类：

  创建型模式(强调对象的创建)：
      1：工厂模式
          1：方法工厂
      2：单例模式
      3：建造者模式
      4：原型模式
      5：抽象工厂模式        
  结构型模式(站在软件结构上解决问题)：
      1：适配器模式
      2：装饰器模式
      3：代理模式
          1):静态代理
          2):动态代理
      4：外观模式
      5：桥接模式
      6：组合模式
      7：享元模式
  行为型模式(站在方法上思考问题)：            
      1：责任链模式
      2：策略模式
      3：模板方法模式
      4：观察者模式
      5：迭代子模式
      6：命令模式
      7：备忘录模式
      9：状态模式
      10：访问者模式
      11：中介者模式
      12;解释器模式
  

1）单例模式

1.1）解决什么问题

• 解决：在整个软件系统中，对于某个类只能存在一个对象实例，并且该类提供取得该类对象实例的静态方法，目的节省空间

1.2）饿汉式(静态常量)

• 优点：避免了线程同步的问题，在加载的时候就完成实例化

• 缺点：如果未使用到这个对象，可能造成内存浪费，没有达到懒加载效果

  public  class HungryMan{
      private static final HungryMan hungryMan = new HungryMan();
      private HungryMan() {
  
      }
      public static HungryMan getInstance(){
          return hungryMan;
      }
  }
  

1.3） 饿汉式(静态代码块)

• 优点：避免了线程同步的问题，在加载的时候就完成实例化

• 缺点：如果未使用到这个对象，可能造成内存浪费，没有达到懒加载效果

  public  class HungryMan{
      private static  HungryMan hungryMan = null;
      static {
         hungryMan = new HungryMan();
      }
      private HungryMan() {
  
      }
      public static HungryMan getInstance(){
          return hungryMan;
      }
  }
  

1.4）懒汉式(线程不安全)

• 优点：起到懒加载效果，但是只能单线程使用

• 缺点：多线程环境不安全，可能重复创建了对象，不符合单例模式的初衷

  public  class LazyMan{
      private static LazyMan lazyMan = null;
  
  
      private LazyMan() {
  
      }
  
      public  static  LazyMan getInstance(){
          if (lazyMan == null) {
              lazyMan = new LazyMan();
          }
          return lazyMan;
      }
  }
  

1.5）懒汉式(线程安全，同步方法)

• 优点：线程安全

• 缺点：效率低

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

1.6）懒汉式(线程不安全，同步代码块)

• 优点：起到懒加载效果，但是只能单线程使用

• 缺点：线程不安全，多线程环境下不安全

  public  class LazyMan{
      private static LazyMan lazyMan = null;
      private LazyMan() {
      }
      public  static     synchronized LazyMan getInstance(){
          if (lazyMan == null) {
              synchronized (LazyMan.class){
                  lazyMan = new LazyMan();
              }
          }
          return lazyMan;
      }
  }
  

1.7）双重检查

• 优点：可以实现懒加载、线程安全、效率高。几乎完美，除了反射可以爆破

  public static class LazyMan{
      private static volatile  LazyMan lazyMan = null;
      private LazyMan() {
      }
      public  static     synchronized LazyMan getInstance(){
          if (lazyMan == null) {
              synchronized (LazyMan.class){
                  if (lazyMan == null) {
                      lazyMan = new LazyMan();
                  }
              }
          }
          return lazyMan;
      }
  }
  

1.8）静态内部类

• **优点：线程安全(jvm虚拟机装载类的时候会发生STW事件所以是线程安全的)，懒加载 **

• 缺点：占空间

  /**
   * 静态内部类
   * @author xxl
   * @date 2023/4/19
   */
  public class StaticInnerClass {
      private StaticInnerClass(){}
      public static class InnerClas{
          private static final StaticInnerClass staticInnerClass = new StaticInnerClass();
  
      }
      public static StaticInnerClass getInstance() {
          return InnerClas.staticInnerClass;
      }
  }
  

1.9）枚举

• 优点：线程安全，自带单例模式，防止序列化创建新对象

  /**
   * 单例模式：枚举
   * @author xxl
   * @date 2023/4/19
   */
  public class EnumClass {
      public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
          InnerClass instance = InnerClass.INSTANCE;
      }
  
      public enum  InnerClass{
          INSTANCE;
          public void say() {
              System.out.println("hello");
          }
      }
  }
  

1.10）总结

• 构造器一定私有

• 单例模式共有8种写法，5种分类

  1. 饿汉：2种
  2. 懒汉：3种
  3. 双重检查
  4. 静态内部类
  5. 枚举

• 前四种不安全，反射可以破解