单例模式

单例模式

作为对象的创建模式，单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。 –《JAVA与模式》

目前众所周知，单例模式主要有两种实现方式，一种是懒汉式，一种是饿汉式；其中懒汉式比较容易理解，但是作为饿汉式在实现的时可能有点麻烦。

• 饿汉式

  饿汉式指的是在对象初始化的时候，那么就提供该对象的实例提供外部访问，无论外界是否真的需要该对象的实例。

  public class EagerSingleton {
  
      private static final EagerSingleton eagerSingleton = new EagerSingleton();
  
          /**私有化构造方法，不对外提供出去*/    
      private EagerSingleton () {
  
      }
  
      public static EagerSingleton getInstance() {
          return eagerSingleton;
      }
  }
  

• 懒汉式

  懒汉式对比与饿汉式，他不会想饿汉式在初始化对象就实例化对象出来，与之不同的是在外部需要获取该对象的实例时，才初始化对象，这样做的好处就是在一定程度上节省的内存的消耗

  public class LazySingleton {
  
      private static LazySingleton lazySingleton = null;
  
      /**私有化构造方法，不对外暴露*/
      private LazySingleton() {
  
      }
  
      /**
       * 提供公共获取对象实例方法暴露出去
       * 这里添加synchronized是为了在多线程环境下，保证依然提供单例出去；
       * 比如说A，B两个线程同时进入getInstance方法中，两个线程在判断lazySingleton是否为null时，都是true，那么就会提供两个不通过的实例化对象出去
       * @return
       */
      public static synchronized LazySingleton getInstance() {
          if (lazySingleton == null) {
              lazySingleton = new LazySingleton();
              return lazySingleton;
          }
          return lazySingleton;
      }
  }

  但是关于上面懒汉式的实现有一个瑕疵，就是每一次在去获取LazySingleton实例化是都需要上一个线程在获取结束之后，这样有一定的性能的问题，当然我们可以对这里的代码进行优化。

  public class DoubleLockLazySingleton {
  
      /**
       * 这里使用volatile关键字，是为了保证doubleLockLazySingleton在多线程环境下保持一致性，
       * 所谓的一致性指的是N个线程在同时对doubleLockLazySingleton进行处理时，其中任意线程在对
       * doubleLockLazySingleton已经进行了改变，那么其他线程可以马上获取到改变之后的doubleLockLazySingleton
       */
      private static volatile DoubleLockLazySingleton doubleLockLazySingleton = null;
  
      private DoubleLockLazySingleton() {
  
      }
  
      public static DoubleLockLazySingleton getInstance() {
          // 初次判断doubleLockLazySingleton是否为空，
          if (doubleLockLazySingleton == null) {
              synchronized (DoubleLockLazySingleton.class) {
                  // 再次判断是之前的判断是处于线程不安全的，所以需要再次判断，防止发生并发问题
                  if (doubleLockLazySingleton == null) {
                      doubleLockLazySingleton = new DoubleLockLazySingleton();
                      return doubleLockLazySingleton;
                  }
              }
          }
          return doubleLockLazySingleton;
      }
  }

  这里笔者提供两种其他关于单例懒汉式的实现

  • 内部类实现

  public class InnerClassLazySingleton {
  
      private InnerClassLazySingleton() {
  
      }
  
      private static class InnerClassLazySingletonHolder {
  
          private static InnerClassLazySingleton InnerClassLazySingleton = new InnerClassLazySingleton();
      }
  
      public static InnerClassLazySingleton getInstance() {
          /**
           * 这里之所以使用内部类的实现方式，是因为在JVM在加载类中的静态字段（或者静态代码块）是保证同步的，
           * 也就是说在N个线程在同步访问getInstance方法时，这里是去加载了InnerClassLazySingleton
           * 中的内部静态类InnerClassLazySingletonHolder，而加载内部静态类时又是同步的，那么就代表着
           * 这里只有一个线程加载了InnerClassLazySingletonHolder，而且作为一个静态内部类而言，他在整个
           * 系统中只会加载一次，他的生命周期是伴随着InnerClassLazySingleton而存在的
           */
          return InnerClassLazySingletonHolder.InnerClassLazySingleton;
      }
  }

  • 枚举单例实现

  public enum EnumSingleton {
  
      SINGLETON;
  
      public void doSomething() {
          // TODO
      }
  }

  以上所有内容转自《JAVA与模式》之单例模式