单例的几种实现方式

单例模式的定义：

单例模式是一种常用的软件设计模式，其定义是单例对象的类只能允许一个实例存在。

许多时候整个系统只需要拥有一个的全局对象，这样有利于我们协调系统整体的行为。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息。这种方式简化了在复杂环境下的配置管理。

单例模式的优缺点：

　　优点：

　　1、提供了对唯一实例的受控访问；

　　2、Java中频繁创建和销毁类对象都会占用一部分系统资源，使用单例模式可以提高性能；

　　3、允许可变数量的实例；

　　缺点：

　　1、单例模式中，没有抽象层，所以对于单例类的扩展并不方便；

　　2、单例类的职责过重，在一定程度上违背了“单一职责原则”；

　　3、滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失；

单例的几种写法：

1.懒汉模式（线程不安全）

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

这种写法lazy loading很明显，但是致命的是在多线程不能正常工作。

2.懒汉模式（线程安全）

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

这种写法能够在多线程中很好的工作，而且看起来它也具备很好的lazy loading，但是，遗憾的是，效率很低，99%情况下不需要同步。

3.饿汉

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

这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用getInstance方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到lazy loading的效果。

4.饿汉（变种）

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

表面上看起来差别挺大，其实更第三种方式差不多，都是在类初始化即实例化instance。

5.静态内部类

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

这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程，它跟第三种和第四种方式不同的是（很细微的差别）：第三种和第四种方式是只要Singleton类被装载了，那么instance就会被实例化（没有达到lazy loading效果），而这种方式是Singleton类被装载了，instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance。想象一下，如果实例化instance很消耗资源，我想让他延迟加载，另外一方面，我不希望在Singleton类加载时就实例化，因为我不能确保Singleton类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化instance显然是不合适的。这个时候，这种方式相比第三和第四种方式就显得很合理。

6.枚举

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

这种方式是Effective Java作者Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

7.双重检验锁（推荐）

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

Double-Check概念对于多线程开发者来说不会陌生，如代码中所示，我们进行了两次if (singleton == null)检查，这样就可以保证线程安全了。这样，实例化代码只用执行一次，后面再次访问时，判断if (singleton == null)，直接return实例化对象。

　　优点：线程安全；延迟加载；效率较高。

注：双重校验锁为什么要在singleton上加volatile关键字：假设没有关键字volatile的情况下，两个线程A、B，都是第一次调用该单例方法，线程A先执行instance = new Instance()，该构造方法是一个非原子操作，编译后生成多条字节码指令，由于JAVA的指令重排序，可能会先执行instance的赋值操作，该操作实际只是在内存中开辟一片存储对象的区域后直接返回内存的引用，之后instance便不为空了，但是实际的初始化操作却还没有执行，如果就在此时线程B进入，就会看到一个不为空的但是不完整（没有完成初始化）的Instance对象，所以需要加入volatile关键字，禁止指令重排序优化，从而安全的实现单例。创建对象可以分解为如下的3行伪代码

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

上面3行代码中的2和3之间，可能会被重排序导致先3后2