随笔-设计模式-单例模式

单例模式

所谓单例，即为仅此一例。在整个系统中，一个类只有一个实例对象，并且该类只提供一个取得实例的静态方法。
八种单例模式：

• 饿汉式（静态常量）
• 饿汉式（静态代码块）
• 懒汉式（线程不安全）
• 懒汉式（同步方法，线程安全）
• 懒汉式（同步代码块，线程安全）
• 双重检查
• 静态内部类
• 枚举

一、饿汉式（静态常量）

• 类的内部创建私有对象
• 构造器私有化
• 对外暴露一个静态方法，用来获取实例

public class SingleTon {
  private static final SingleTon SINGLE_TON = new SingleTon();
  public static SingleTon getInstance() {
    return SINGLE_TON;
  }
  private SingleTon() {
  }
}

优点：简单，利用了类加载机制，在类加载时候完成了实例化，避免了线程同步问题。
缺点：没有达到Lazy Loading的效果。如果始终没有使用这个实例，那么就会造成内存浪费。

二、饿汉式（静态代码块）

跟上面差不多，也是在类加载时候完成实例化。

public class SingleTon {
  private static final SingleTon SINGLE_TON;
  static {
    SINGLE_TON = new SingleTon();
  }
  public static SingleTon getInstance() {
    return SINGLE_TON;
  }
  private SingleTon() {
  }
}

优缺点同上。

三、懒汉式（线程不安全）

• 构造器私有化
• 对外暴露一个静态方法，用来获取实例
• 在调用静态方法时候才创建实例

public class SingleTon {
  private static SingleTon SINGLE_TON;

  private SingleTon() {
  }

  public static SingleTon getInstance() {
    if (SINGLE_TON == null) {
      SINGLE_TON = new SingleTon();
    }
    return SINGLE_TON;
  }
}

优点：有Lazy Loading效果
缺点：线程不安全，只能在单线程下使用

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

在上面基础加上同步锁

public class SingleTon {
  private static SingleTon SINGLE_TON;

  private SingleTon() {
  }

  public static synchronized SingleTon getInstance() {
    if (SINGLE_TON == null) {
      SINGLE_TON = new SingleTon();
    }
    return SINGLE_TON;
  }
}

优点：有Lazy Loading效果，并且线程安全
缺点：因为有同步锁，效率低

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

跟上面差不多，只是缩小了同步范围

public class SingleTon {
  private static SingleTon SINGLE_TON;

  private SingleTon() {
  }

  public static SingleTon getInstance() {
    if (SINGLE_TON == null) {
      synchronized (SingleTon.class) {
        SINGLE_TON = new SingleTon();
      }
    }
    return SINGLE_TON;
  }
}

优缺点同上

六、双重检查

在懒汉式（同步代码块，线程安全）基础上优化

public class SingleTon {
  private volatile static SingleTon SINGLE_TON;

  private SingleTon() {
  }

  public static SingleTon getInstance() {
    if (SINGLE_TON == null) {
      synchronized (SingleTon.class) {
        if (SINGLE_TON == null) {
          SINGLE_TON = new SingleTon();
        }
      }
    }
    return SINGLE_TON;
  }
}

优点：利用了Double-Check，既保证了线程安全，又减少了同步代码块的执行，还实现了Lazy Loading
缺点：一开始，会有部分线程会执行两次判断（影响可以忽略）

七、静态内部类

• 构造器私有化
• 写一个静态内部类，该类中有一个静态属性SingleTon
• 对外暴露一个静态方法，用来获取实例

public class SingleTon {
  private SingleTon() {
  }

  private static class InnerSingleTon {
    private static final SingleTon SINGLE_TON = new SingleTon();
  }

  public static SingleTon getInstance() {
    return InnerSingleTon.SINGLE_TON;
  }
}

优点：利用类加载机制（静态内部类在类加载时候不会实例化，在被调用时候才会实例化），实现Lazy Loading，线程安全，效率高

八、枚举

public enum SingleTon {
  SINGLE_TON;

  public void doSome() {
    System.out.println("ok");
  }

}

优点：线程安全，防止反序列化重新创建新的对象

总结

双重检查、 静态内部类、枚举都推荐使用，个人用最后两种比较多