Java设计模式--单例模式

前言

单例模式主要是保证了一个对象在整个系统之内，只实例化了一次。一般是业务需要实例一次，或者创建资源消耗太多，只实例一次。
特点：
1.单例保证只实例化一次，并给系统提供。
2.构造函数是私有的，不能外部进行实例化。

常用实现

单例模式一般实现很多，但是有些是安全的，有些是非安全的，还有实现时间的不同。先介绍常用的安全的实现方式。

饿汉式

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

代码如上，这是安全的实现方式。通过采取类加载的机制，保证单例的线程安全。类刚被创建，就进行初始化操作了，属于饿汉方式。

懒汉式

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

代码如上，这是安全的实现方式。不过instance的实现靠后了，进行了是否为null的判断，只有不为null的时候，才进行初始化操作，由synchronized保证线程安全。由于是需要时，才进行初始化操作，所以属于懒汉方式。

优化–基于类的初始化实现

对于单例模式，还可以采取java类的初始化方式实现。在JVM完成类的初始化阶段内，它是线程安全的。所说的类初始化阶段指，JVM在将Class加载之后，交付给线程使用之前，这个阶段内是线程安全的。当类被初始化时，JVM会去获取一个锁，保证类的初始化只有一个线程存在，在类初始化完成之后，在进行类的使用。
前面的饿汉式单例就是基于此，保证了类初始化的时候是线程安全的，还可以根据此机制，采取内部类实现。

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

相较于懒汉式方式，这个更好一些。它不是直接进行instance的new操作，而是等到getInstance()触发式，才进行真正的new操作，初始化有一定的延迟性。

优化–双重检测

对于懒汉式来说，类的加载实现了线程安全，但是由于采取了synchronized关键字，导致性能下降，此时，我们可以采取安全的双重检测进行单例的实现。

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

如上所示，首先我们进行了volatile限定，其次再获取时，进行的双重判断，保证了类的线程安全的初始化操作。
对于类为什么需要volatile限定，首先我们需要了解下类的初始化和重排序。对于重排序，java的代码执行，并不是完全按照代码书写的方式展现的，它的一些代码会进行颠倒顺序（保证处理器的性能），导致真正的执行和我们预想的不一致。但是这个重排序会限制，它会保证单线程内，无论如何排序，结果是一定的，不会被干扰，所有我们看到的单线程代码执行是顺序执行的，是符合预期的。（详细参考指令重排序）
其次，instance = new Singleton()这步操作，不是单一的操作。他可以进行分解，即1.给Singleton分配内存空间；2.初始化Singleton对象；3.将instance指向刚分配的内存地址。所以，可以看到它的操作是3步。而这个3步的顺序，是可以打乱的。即可能出现，1->3->2情况，此情况下，会导致instance刚分配到内存地址时，其他线程已经开始使用了，导致使用的对象是空的，还没有初始化过。
由于上述的执行重排序，所以类要加上volatile关键字，它能防止指令重排序，以及多线程下类初始化的访问问题。

非单例错误

仅仅判空操作

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

同饿汉式基本类似，少了synchronized关键字，容易导致多线程下多个单例。
说明：判断instance==null时，多个线程同时判断为null了，初始化了多个。

双重检测无volatile限定

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

同双重检测方式，但是类没有volatile限定，容易导致new Singleton()的1->3->2情况。
说明：线程1进入synchronized代码内，判断instance不为null了，开始进行new Singleton()操作，此操作分为3步。此时，先给instance分配了地址，然后重排序了，直接instance指向了地址；线程2进行getInstance()方式，第一步判断非空时，发现分配了地址，直接使用，导致问题。

枚举安全实现

public enum Singleton {    instance;    public void singletonOperation() {    }}

最后提供一种枚举的方式，由类加载机制保证了线程安全。

---

参考：
1.http://jiangzhengjun.iteye.com/blog/652440
2.http://www.cnblogs.com/java-my-life/archive/2012/03/31/2425631.html#3537918