设计模式 - 单例模式

  单利设计模式在Java中主要用到的是懒汉模式和饿汉模式。顾名思义，懒汉模式就是说你不使用，它就永远不生成实例；饿汉模式就是，肚子饿了，自己就会找东西，在你没调用之前就已经生成对象，等着被调用。

饿汉模式

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

  类的构造函数定义为private的，保证其他类不能实例化此类，然后提供了一个静态实例并返回给调用者。饿汉模式是最简单的一种实现方式，饿汉模式在类加载的时候就对实例进行创建，实例在整个程序周期都存在。它的好处是只在类加载的时候创建一次实例，不会存在多个线程创建多个实例的情况，避免了多线程同步的问题。它的缺点也很明显，即使这个单例没有用到也会被创建，而且在类加载之后就被创建，内存就被浪费了。

懒汉模式

public class Singleton{  
    private volatile static Singleton instance = null;  //1
    private Singleton(){}  
    public static Singleton getInstance(){  
       if(instance == null){                            //2
           synchronized (Singleton.class){              //3
               if(instance == null){                    //4
                   instance = new Singleton();
               }
           }
       } 
       return instance;
    }  
}  

  这个懒汉模式就有很大的说头了。懒汉模式的代码如此复杂最终的目的就是让懒汉在多线程下也能够安全运行。
  当多个线程分先后到达2处的时候，要是instance已被实例化那就可以快速返回了。3处设立的目的，就是当多个线程同时到达并同时通过了2，这个时候因为instance并没有实例化，所以多线程要对instance实例化进行同步，不然就要多次创建对象和一些线程不安全引起的错误。4处的目的是3处写法引起的，3处有多个线程在等待，一旦第一个线程创建完了，其他线程还在排队，这个时候允许通过3，就不需要再创建了，直接返回。
  重点在1处。1处的写法有些奇怪，为什么还要volatile？这是因为java的JVM指令重排。编译器对 instance = new Singleton();编译成JVM指令是

memory = allocate();  //1:分配对象的内存对象
ctorInstance(memory); //2:初始化对象
instance = memory;    //3:将instance指向刚才那个分配出来的地址

  如果JVM一直是这个顺序那就没什么问题了，但是JVM会优化，优化后如果2和3的顺序颠倒，即先给一个可用的地址然后再初始化，这个时候有一个线程进入getInstance，发现instance地址不为空，但这个时候并没有完成初始化。这就造成不安全场景，所以需要volatile。volatile的作用就是阻止变量访问前后的指令重排，保证指令的执行顺序。

静态内部类

public class Singleton {
    private static class LazyHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
    private Singleton (){}
    public static Singleton getInstance() {
        return LazyHolder.INSTANCE;
    }
}

  大致看上去和饿汉模式差不多，但是还是有区别的。INSTANCE对象初始化的时机并不是在单例类Singleton被加载的时候，而是在调用getInstance方法，使得静态内部类LazyHolder被加载的时候。因此这种实现方式是利用classloader的加载机制来实现懒加载，并保证构建单例的线程安全。

枚举实现

public enum PizzaDeliverySystemConfiguration {
    INSTANCE;
    PizzaDeliverySystemConfiguration() {
        // Initialization configuration which involves
        // overriding defaults like delivery strategy
    }
 
    private PizzaDeliveryStrategy deliveryStrategy = PizzaDeliveryStrategy.NORMAL;
 
    public static PizzaDeliverySystemConfiguration getInstance() {
        return INSTANCE;
    }
 
    public PizzaDeliveryStrategy getDeliveryStrategy() {
        return deliveryStrategy;
    }
}

  为什么要讲枚举实现，原因很简单，通过静态内部类或者单例模式都可以通过反射机制来打破单例的限制。而枚举实现就不能。使用枚举来实现单实例控制会更加简洁，而且无偿地提供了序列化机制，并由JVM从根本上提供保障，绝对防止多次实例化，是更简洁、高效、安全的实现单例的方式。

PizzaDeliveryStrategy deliveryStrategy = PizzaDeliverySystemConfiguration.getInstance().getDeliveryStrategy();