一个类只允许创建一个对象或实例

    实现

    1. 饿汉式 在类加载的时候就已经初始化好了

      1. //饿汉式 在类加载的时候就初始化好了
      2. public class Singleton01 {
      3.  private static final Singleton01 instance = new Singleton01();
      4.  private Singleton01() {}
      5.  public static Singleton01 getInstance() {
      6.      return instance;
      7.  }
      8. }

    2. 懒汉式 支持延时加载，在需要的时候在加载

      1. //懒汉式 在需要的时候加载
      2. public class Singleton02 {
      3.  private static  Singleton02 instance;
      4.  private Singleton02() {}
      5.  public static synchronized Singleton02 getInstance() {
      6.      if (instance == null) {
      7.          return new Singleton02();
      8.      }
      9.      return instance;
      10.  }
      11. }

    3. 双重检查 懒汉式的并发度是比较低的，因此出现了双重检查的模式

      1. //双重检查
      2. public class Singleton3 {
      3.  private volatile static Singleton3 instance;
      4.  private Singleton3(){}
      5.  public static Singleton3 getInstance() {
      6.      if (instance == null) {
      7.          synchronized(Singleton3.class) {
      8.              if (instance == null) {
      9.                  instance = new Singleton3();
      10.              }
      11.          }
      12.      }
      13.      return instance;
      14.  }
      15. }

    4. 静态内部类 静态内部类在外部类被加载的时候并不会加载，只有调用getInstance()方法的时候才会加载进来

      1. public class Singleton04 {
      2.  private Singleton04() {}
      3.  private static class SingletonHandler{
      4.      private static Singleton04 instance = new Singleton04();
      5.  }
      6.  public static Singleton04 getInstance() {
      7.      return SingletonHandler.instance;
      8.  }
      9. }

    5. 枚举 

      1. public enum  Singleton05 {
      2.  INSTANCE;
      3.  public void test(){
      4.      System.out.println("test....");
      5.  }
      6. }

    单例模式存在的问题

    • 对OOP支持不太友好
    • 会隐藏类之间的依赖关系
    • 扩展性不好
    • 可测试性不好
    • 不支持有参数的构造函数