手写单例模式

一、饿汉

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

二、懒汉

public class LazySingleton {
  private static LazySingleton instance;
  private LazySingleton() {
  }
  //每次调用 getInstance() 方法，都需要对这个类加锁
  public static synchronized LazySingleton getInstance() {
    if (instance == null) {
      instance = new LazySingleton();
    }
    return instance;
  }
}

三、双重加锁的懒汉

但是感觉这种写法很丑

public class UglyLazySingleton {
  private static UglyLazySingleton instance;
  private UglyLazySingleton() {
  }
  //只有instance=null的时候才需要加锁
  public static UglyLazySingleton getInstance() {
    if (instance == null) {
      synchronized (UglyLazySingleton.class) {
        if (instance == null) {
          instance = new UglyLazySingleton();
        }
      }
    }
    return instance;
  }
}

四、使用静态内部类的懒汉

public class LazySingleton {
  private LazySingleton() {
  }
  //静态内部类只有在被使用的时候才会被加载，且只会加载一次
  private static class SingletonHolder {
    private static LazySingleton instance = new LazySingleton();
  }
  public static LazySingleton getInstance() {
    return SingletonHolder.instance;
  }
}