单例模式

确保在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法）。例：数据库客户端，确保一个客户访问就只创建一个访问类。

• 饿汉式（静态常量）

  class Singleton{
      // 构造器私有化
      private Singleton(){
          
      }
      // 本类内部创建对象实例
      private final static Singleton instance = new Singleton();
      // 提供一个共有的静态方法，返回实例对象
      public static Singleton getInstance(){
          return instance;
      }
  }
  

  在类加载时就完成了实例化，避免了线程同步问题，但如果实例未被使用则造成了内存浪费。

• 饿汉式（静态代码块）

  class Singleton{
      // 构造器私有化
      private Singleton(){
          
      }
      // 本类内部创建对象实例
      private static Singleton;
      // 在静态代码块中，创建单例对象
      static{ 
          instance = new Singleton();
      }
      // 提供一个共有的静态方法，返回实例对象
      public static Singleton getInstance(){
          return instance;
      }
  }
  

  同上。

• 懒汉式（线程不安全）

  class Singleton {
      private static Singleton instance;
      private Singleton(){}
      //使用该静态方法时，才去创建instance
      public static Singleton getInstance() {
          if(instance == null){
              instance = new Singleton();
          }
          return instance;
      }
  }
  

  起到了懒加载的作用，线程不安全,实际开发不用。一个线程进入了判断语句还未来得及向下执行，另一个线程也通过了判断语句，会产生多个实例。

• 懒汉式（线程安全，同步方法）

  class Singleton {
      private static Singleton instance;
      private Singleton(){}
      //同步处理，解决线程安全问题
      public static synchronized Singleton getInstance() {
          if(instance == null){
              instance = new Singleton();
          }
          return instance;
      }
  }
  

  效率低，实际开发中不用。

• 懒汉式（线程安全，同步代码块）

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

  线程不安全，错误方法，不用。

• 双重检查

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

  double-check多线程中常用到，进行了两次if检查，可保证线程安全。实例化代码只执行一次，后面再次访问时，判断if，直接return实例化对象，避免反复进行方法同步。线程安全、延迟加载、效率极高。

• 静态内部类

  class Singleton{
      private static volatile Singleton instance;
      private Singleton(){}
      private static class SingletonInstance{
          private static final Singleton INSTANCE = new Singleton();
      }
      public static synchronized Singleton getInstance(){
          return SingletonInstance.INSTANCE;
      }
  }
  

  静态内部类SingletonInstance在Singleton类加载时不会被加载，当调用getInstance()时，SingletonInstance类会被加载，Singleton类才会被实例化。类的静态属性只会在第一次加载类的时候初始化，且在类加载过程中始终线程安全（JDK确保）。线程安全、利用静态内部类特点实现延迟加载，效率高。推荐使用。

• 枚举

• enum Singleton{
      INSTANCE;
      public void sayOK(){
          System.out.printlen("ok");
      }
  }
  

  枚举线程安全、防止反序列化重新创建新的对象，推荐使用。