单例设计模式

保证对象唯一性

• 饿汉单例类：

class EagerSingleleton {
  private static EagerSingleleton instance = new EagerSingleleton();
  private EagerSingleleton(){};
  public static EagerSingleleton getInstance(){
    return instance;
  }
}

解释：当类被加载时，静态变量instance会被初始化，此时类的私有构造函数会被调用，单例类的唯一实例被创建。

• 懒汉式单例类：

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

解释：解决了多线程同时访问的问题，但是每次调用实例方法时候都需要进行线程锁定判断，在高并发环境下将会导致性能大大降低。

• 懒汉式单例类优化1：

class LazySingleleton {
  private static LazySingleleton instance = null;
  private LazySingleleton(){};
  public static LazySingleleton getInstance(){
    if (instance == null) {//1
      synchronized(LazySingleleton.class) {//2
        instance = new LazySingleleton();//3
      }
    }
    return instance;
  }
}

解释：解决了高并发的性能问题，但是存在对象不唯一的情况。例如当A,B两个线程先后到达了1处，判断了instance==null，此时A线程被挂起，B线程创建了对象，当B线程完成了对象的创建后，A线程获取执行权，同样进行对象的创建过程，此时A,B两个线程都创建了一个instance，导致对象不唯一，解决办法：双重检查锁定。

• 懒汉式单例类优化2（double-check）：

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

解释：解决了对象不唯一的情况，并且也解决了每次获取对象时线程锁定带来的性能问题，但是使用了volatile修饰符，屏蔽了虚拟机对代码的优化，也可能导致系统运行效率降低，因此该中方案并不是最优的方案。

饿汉式单例类与懒汉式单例类的比较

饿汉式：类的创建过程在类加载的时候完成，也就是不论该类是否使用都会被加载的内存中，从资源的利用效率上来看，饿汉式不如懒汉式单例。
懒汉式：在第一次使用类的时候创建对象，无须一直占用系统资源，实现了延时加载，但是必须处理好线程的访问的问题，在多线程创建对象时需要考虑检查锁的问题，这将导致系统性能的损失。

一个更好的单例实现方法：

• 目前遇到的问题：
  • 饿汉式不能实现延时加载，任何时候都占据内存。
  • 懒汉式需要考虑多线程的访问，存在性能损失。
• 更好的处理方法：

class Singleton{
  private Singleton(){}
  private static class HolderClass{
    private final static Singleton instance = new Singleton();
  }
  public static Singleton getInstance(){
    return HolderClass.instance;
  }
}

解释：如何解决目前遇到的问题：

• 延时加载：在调用getInstance()方法时，会首次加载内部类HodlerClass，在加载内部类的同时会初始化静态成员变量instance。
• 多线程问题：初始化对象的过程在内部类HolderClass初始化的同时完成的，所有线程的安全性由Java虚拟机来保证，并可以确保变量只能初始化一次。并且该方法没有任何线程锁定，因此没有性能影响。

单例类的优缺点：

• 主要优点：
  • 提供了对唯一实例的控制，可以严格控制客户何时访问。
  • 在内存中只存在一个对象，因此可以节约系统资源。
• 主要缺点：
  • 无抽象层，不易扩展。

适用场景:

• 系统只使用一个实例对象。