在一个应用程序里面，某个类的实例对象只有一个，你没办法去new，因为构造器是被 private 修饰的，易班通过其get方法获取到他们的实例。

懒汉式单例

  1. // 线程不安全
  2. public class Singleton {
  4.     private static Singleton singleton;
  6.     private Singleton() {
  7.     }
  9.     public static Singleton getInstance() {
  10.         if(singleton == null) {
  11.             singleton = new Singleton();
  12.         }
  13.         return singleton;
  14.     }
  15. }
  17. // 线程安全
  18. public class Singleton {
  19.     private static Singleton singleton;
  21.     private Singleton() {
  22.     }
  24.     public static synchronized Singleton getInstance() {
  25.         if(singleton == null) {
  26.             singleton = new Singleton();
  27.         }
  28.         return singleton;
  29.     }
  30. }

懒汉式单例—双重检验

  1. public class Singleton {
  2.     // volatile 避免指令重排序问题
  3.     private volatile static Singleton singleton;
  5.     private Singleton () {
  7.     }
  9.     public static Singleton getInstance() {
  10.         if(singleton == null) {
  11.             synchronized(Singleton.class) {
  12.                 if(singleton == null) {
  13.                     // 保证singleon在多线程中的可见性，可以立即刷新到主内存
  14.                     // new Singleton() （1-开辟空间，2-初始化空间，3-赋值实例对象）
  15.                     // 操作会发生指令重排
  16.                     // new创建了实例并赋值给了singleton，但是构造方法初始化空间步骤并未执行
  17.                     singleton = new Singleton();
  18.                 }
  19.             }
  20.         }
  21.         return singleton;
  22.     }
  23. }

饿汉式单例

  2. // 静态常量方式
  3. public class Singleton {
  5.     private final static Singleton instance = new Singleton();
  7.     private Singleton() {
  8.     }
  10.     public static Singleton getInstance() {
  11.         return instance;
  12.     }
  13. }
  15. // 静态代码块方式
  16. public class Singleton {
  18.     private static Singleton instance;
  20.     static {
  21.         instance = new Singleton();
  22.     }
  24.     private Singleton() {
  25.     }
  27.     public static Singleton getInstance() {
  28.         return instance;
  29.     }
  30. }

静态内部类

  1. public class Singleton {
  2.     private static class SingletonHolader {
  3.         private static final Singleton INSTANCE = new Singleton();
  4.     }
  6.     private Singleton() {
  7.     }
  9.     public static final Singleton getInstance() {
  10.         return SingletonHolder.INSTANCE;
  11.     }
  12. }

枚举

  1. public enum Singleton {
  2.     INSTANCE;
  3.     public void whateverMethod() {
  4.     }
  5. }

实际应用场景

1、在Spring中创建的Bean实例默认都是单例模式存在的。
2、网站的计数器，一般也是单例模式实现，否则难以同步。
3、应用程序的日志应用，一般都用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。