单例模式 实现

public class Krryblog {

  // 1.将构造函数私有化，不可以通过 new 的方式来创建对象
  private Krryblog() {}

  // 2.在类的内部创建自行实例
  private static final Krryblog krryblog = new Krryblog();

  // 3.提供获取唯一实例的方法
  public static Krryblog getKrryblog() {
      return krryblog;
  }
}

public class Krryblog {

  // 1. 将构造函数私有化，不可以通过new的方式来创建对象
  private Krryblog(){}

  // 2. 先不创建对象，等用到的时候再创建
  private static Krryblog krryblog = null;

  // 3. 调用到这个方法了，证明是要被用到的了
  public static synchronized Krryblog getKrryblog() {

      // 4. 如果这个对象引用为null，我们就创建并返回出去，不为 null，就不再创建
      if (krryblog == null) {
          krryblog = new Krryblog();
      }

      return krryblog;
  }
}

public class Krryblog {
  private Krryblog() {}

  // 可能会有重排序问题，加上 volatile 关键字解决
  // volatile 有内存屏障的功能
  private static volatile Krryblog krryblog = null;

  public static Krryblog getKrryblog() {
    // 这里判断是否为空，主要是为了提高性能
    if (krryblog == null) {

      // 锁住这里就行了，里面还有一个判断是否为空
      // 将锁的范围缩小，提高性能
      synchronized (Krryblog.class) {

        // 再判断一次是否为null
        // 如果只在外面加 null 判断，若两个线程同时调用 getKrryblog，同时判断外面的 null，那也会创建出两个对象
        // 所以在锁的里面也要加上 null 判断
        if (krryblog == null) {
          krryblog = new Krryblog();
        }
      }
    }
    return krryblog;
  }
}

public class Krryblog {

  private Krryblog() {}

  // 使用内部类的方式来实现懒加载
  private static class LazyHolder {
    // 创建单例对象
    private static final Krryblog INSTANCE = new Krryblog();
  }

  // 获取对象
  public static final Krryblog getInstance() {
    return LazyHolder.INSTANCE;
  }
  
}

public enum Krryblog {

  INSTANCE,

  private Resource resource;
  
  // 创建单例对象
  public Krryblog () {
    resource = new Resource();
  }

  // 获取单例对象
  public Resource getInstance() {
    return resource;
  }
}

public class TestPattern {
 
  public static void main(String[] args) {
      Resource instance = Krryblog.INSTANCE.getInstance();
  }
}