Java设计模式之单例模式

单例模式

介绍

单例模式是Java设计模式中最简单的模式之一。顾名思义，单例模式是为了确保单例类只有一个实例的生成，并提供其他类访问其唯一对象的方式。单例类的实现，需要满足以下几点:

1. 拥有唯一实例
2. 构造方法私有化，实例由自己生成
3. 提供其他对象获取唯一实例的方法
   

实现方式

1. 饿汉模式

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

   饿汉模式下，单例类的实例在类加载的时候创建。优点是实例只会创建一次，没有线程问题。缺点是不管这个单例类有没有被使用，实例都会被创建，浪费内存。

2. 懒汉模式

   public class Singleton {
       private static Singleton singleton = null;
       private Singleton() {
       }
       public static Singleton getIntance() {
           if (null == singleton) {
               singleton = new Singleton();
           }
           return singleton;
       }
   }

   懒汉模式下，单例类的加载变成了懒加载。只有在单例类被使用的时候才会创建单例类的实例，一定程度上优化了节约了资源。但是这种懒汉模式存在线程安全的问题，因此，在多线程环境下，需要加同步锁解决线程安全问题，优化方式如下：

   public class Singleton {
       private static Singleton singleton = null;
       private Singleton() {
       }
       public static synchronized Singleton getIntance() {
           if (null == singleton) {
               singleton = new Singleton();
           }
           return singleton;
       }
   }

3. 双重校验锁
   加锁的懒汉模式实现了懒加载，又解决了线程安全的问题，看起来似乎已经完美了。但它存在着性能问题，依然不够完美。synchronized修饰的同步方法比一般方法要慢很多，如果调用getInstance()的次数很多的话，对性能的影响就比较大了。因此就有了如下的双重校验锁方式：

   public class Singleton {
       private static Singleton singleton = null;
       private Singleton() {
       }
       public static Singleton getIntance() {
           if (null == singleton) {
               synchronized (Singleton.class) {
                   if (null == singleton) {
                       singleton = new Singleton();
                   }
               }
           }
           return singleton;
       }
   }

   双重校验锁方式取消了getIntance()方法的同步，而是在方法内部创建单例类实例的时候加锁同步。这样做的好处是当单例类被创建后，再次调用getIntance()的时候，不会再走到同步代码块内，从而提高了性能。这下看起来好像真的完美了。
   遗憾的是，由于Java的指令重排优化，在多线程环境下，双重校验锁方式依然会存在问题。原因出在singleton = new Singleton();这段赋值语句上，因为它不是一个原子操作，实际上可以拆解为下面这几条jvm指令：

   //1.分配对象的内存空间 
   memory = allocate();
   //2.初始化对象 
   ctorInstance(memory);  
   //3.设置singleton指向刚分配的内存地址
   singleton = memory;

   上面的操作2依赖于操作1，但是操作三并不依赖于操作2。因此JVM是可以针对它们进行指令的优化重排序的，经过重排序后如下：

   //1.分配对象的内存空间 
   memory = allocate();
   //3.设置singleton指向刚分配的内存地址
   singleton = memory;
   //2.初始化对象 
   ctorInstance(memory);  
   

   可见，在指令重排后，singleton指向分配好的内存放在了前面，而这段内存的初始化被排在了后面。这就导致，假如某个线程在执行这段赋值语句时，在把内存分配给singleton而内存还未被初始化的时候，另一个线程进入方法判断singleton引用不为null，然后就将其返回使用，导致出错。
   上面这段伪代码演示的情况不仅是可能的，而且是一些JIT编译器上真实发生的现象。解决的方法是使用volatile关键字，在jdk1.5后，volatile修饰的变量可以禁止指令重新排序。

   public class Singleton {
       private static volatile Singleton singleton = null;
       private Singleton() {
       }
       public static Singleton getIntance() {
           if (null == singleton) {
               synchronized (Singleton.class) {
                   if (null == singleton) {
                       singleton = new Singleton();
                   }
               }
           }
           return singleton;
       }
   }

4. 静态内部类

   public class Singleton {
       private Singleton() {
       }
       private static class SingletonHolder {
           public static Singleton singleton = new Singleton();
       }
       public static Singleton getIntance() {
           return SingletonHolder.singleton;
       }
   }

   这种方式和饿汉模式一样，利用类加载机制来保证单例。但比饿汉模式优化的地方在于，单例对象的实例是在内部类中初始化。这样的话，只有在使用getIntance()方法的时候，才会去初始化单例类的实例。因此，这种方式既实现了懒加载，又能保证线程安全。

5. 枚举

   public enum Singleton {
       INSTANCE;
       public void whateverMethod(){};
   }