架构- - java设计模式-

前言
- 1：什么是单例模式
- 2：单例模式的几种应用设计

单例模式

前言

单例模式详细整理（内含各种方案和分析）

1：什么是单例模式

单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。
在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态，避免政出多头。

2：单例模式的几种应用设计

饿汉式（立即加载方式）

// 饿汉式单例
public class Singleton1 {
  // 私有构造
  private Singleton1() {}

  private static Singleton1 single = new Singleton1();

  // 静态工厂方法
  public static Singleton1 getInstance() {
      return single;
  }
}

饿汉式单例在类加载初始化时就创建好一个静态的对象供外部使用，除非系统重启，这个对象不会改变，所以本身就是线程安全的。(暂不考虑反射的功能)

懒汉式单例（延迟加载方式）

// 懒汉式单例
public class Singleton2 {

  // 私有构造
  private Singleton2() {}

  private static Singleton2 single = null;

  public static Singleton2 getInstance() {
      if(single == null){
          single = new Singleton2();
      }
      return single;
  }
}

多线程环境下会产生多个single对象

懒汉式 + synchronized

public class Singleton3 {
  // 私有构造
  private Singleton3() {}

  private static Singleton3 single = null;

  public static Singleton3 getInstance() {
        
      // 等同于 synchronized public static Singleton3 getInstance()
      synchronized(Singleton3.class){
        // 注意：里面的判断是一定要加的，否则出现线程安全问题
          if(single == null){
              single = new Singleton3();
          }
      }
      return single;
  }
}

先判断是否为null，如果null再实例化new个出来线程安全，但是对资源消耗较大，每个线程都需要排队等待线程释放锁才进行业务判断。

懒汉式 + synchronized （双重检查优化）

public class Singleton4 {
  // 私有构造
  private Singleton4() {}

  private static Singleton4 single = null;

  // 双重检查
  public static Singleton4 getInstance() {
      if (single == null) {
          synchronized (Singleton4.class) {
              if (single == null) {
                  single = new Singleton4();
              }
          }
      }
      return single;
  }
}

先判断null，在synchronized进行判断使用双重检查进一步做了优化，可以避免整个方法被锁，只对需要锁的代码部分加锁，可以提高执行效率。注意：使用了类锁或许会在调用getInstance()时就已经出现锁竞争排队了？···等待校验

静态内部类

public class Singleton6 {
    // 私有构造
    private Singleton6() {}

    // 静态内部类
    private static class InnerObject{
        private static Singleton6 single = new Singleton6();
    }
    
    public static Singleton6 getInstance() {
        return InnerObject.single;
    }
}

单例模式中的静态内部类可以达到线程安全问题，但是如果遇到序列化对象时，使用默认的方式运行得到的结果还是多例的。
java的序列化机制保证在序列化某个对象之前，先调用该对象的writeReplace()方法，如果该方法返回另一个java对象，则系统转为序列化另一个对象。在重写writeResolve后，才能实现替换掉反序列化产生的新对象。
可参考：
1：单例模式之序列化与反序列化实现
2：Java序列化之readObjectNoData、readResolve方法

静态代码块 (思路跟饿汉式差不多，立即加载方式)

public class Singleton6 {
    
    // 私有构造
    private Singleton6() {}
    
    private static Singleton6 single = null;

    // 静态代码块
    static{
        single = new Singleton6();
    }
    
    public static Singleton6 getInstance() {
        return single;
    }
}

内部枚举类

public class SingletonFactory {
    // 内部枚举类
    private enum EnmuSingleton{
        Singleton;
        private Singleton8 singleton;
        
        //枚举类的构造方法在类加载是被实例化 
        private EnmuSingleton(){
            singleton = new Singleton8();
        }
        public Singleton8 getInstance(){
            return singleton;
        }
    }
    public static Singleton8 getInstance() {
        return EnmuSingleton.Singleton.getInstance();
    }
}

class Singleton8{
    public Singleton8(){}
}

如果使用java5提供的enum来定义枚举类，则完全不用担心反序列化带来的新对象问题，而java5以前提供的枚举类例如：Orientation类，可以通过为Orientation类提供一个readResolve()方法来解决该问题，readResolve()方法的返回值将会代替原来反序列化的对象，也就是让反序列化得到的Orientation对象被直接丢弃

拓展：

架构- - java设计模式- - 单例模式

前言

1：什么是单例模式

2：单例模式的几种应用设计

Comments