1.懒汉模式

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

优点：类初始化时，立即加载这个对象。加载类时，天然的是线程安全的
缺点：容易产生垃圾

2.饿汉模式

①线程不安全

public class Singleton_lazy {
    private Singleton_lazy(){};
    private static Singleton_lazy instance = null;
    public Singleton_lazy getInstance(){
        if (instance == null){
            return new Singleton_lazy();
        }
        return instance;
    }
}

优点：延迟加载
缺点：存在线程安全问题：因为判空操作和创建对象不是一个原子操作

②线程安全（双重校验锁）

  解决方案：双重校验锁
  public class Singleton_lazy {
      private Singleton_lazy(){};
      private volatile Singleton_lazy instance = null;
 
      public Singleton_lazy getInstance(){
            //第一次校验singleton是否为空（已经创建实例不用竞争锁，提高效率）
          if(instance == null){
              synchronized (Singleton_lazy.class){
                //第二次校验singleton是否为空
                  if (instance == null){
                      return new Singleton_lazy();
                  }
              }
          }
          return instance;
      }
  }

（1）volatile保证有序性
因为 singleton = new Singleton() 这句话可以分为三步：

1. 为 singleton 分配内存空间；
2. 初始化 singleton；
3. 将 singleton 指向分配的内存空间。
   但是由于JVM具有指令重排的特性，执行顺序有可能变成 1-3-2。 指令重排在单线程下不会出现问题，但是在多线程下会导致一个线程获得一个未初始化的实例。例如：线程T1执行了1和3，此时T2调用 getInstance() 后发现 singleton 不为空，因此返回 singleton， 但是此时的 singleton 还没有被初始化。
   使用 volatile 会禁止JVM指令重排，从而保证在多线程下也能正常执行。