深入解析Java单例模式：饿汉、懒汉与终极模式-优快云博客

先来看一下最简单的单例模式：

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

单例模式有三个要点：

a.一个类只能有一个实例

b.这个类必须自行创建这个实例

c.它必须自行向整个系统提供这个实例

接下来分析一下传说中的饿汉模式：

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

为什么叫做饿汉模式，本人觉得是因为这个类刚一加载就迫不及待的创建了一个实例对象。

这种模式可确保实例的唯一性，但是不管以后用不用，刚一开始就创建，浪费系统资源。

接下来再分下一下和他一起的懒汉模式：

不用说，叫他懒汉肯定是因为他懒惰，不会像饿汉那么着急。

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

这个模式在获取实例的时候会使用synchronized关键字，虽然保证了线程安全，实例唯一，但是每次都会调用synchronized，这样会造成系统性能的降低。这样，我们来再优化一下这段代码：

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

这时候我们对实例对象进行了一次判断，可以大大减少对synchronized的使用次数。但是这样真的最完美了吗？我这么问，可定不是了。

假如在某一瞬间线程A和线程B都在调用getInstance()方法，此时instance对象为null值，均能通过instance == null的判断。由于实现了synchronized加锁机制，线程A进入synchronized锁定的代码中执行实例创建代码，线程B处于排队等待状态，必须等待线程A执行完毕后才可以进入synchronized锁定代码。但当A执行完毕时，线程B并不知道实例已经创建，将继续创建新的实例，导致产生多个单例对象。

所以这是不安全的。我们需要进一步优化，在synchronized中再进行一次(instance==null)判断，这种方式称为：双重检查锁定(Double-Check Locking)。代码如下：

class LazySingleton { 
    private volatile static LazySingleton instance = null; 
    private LazySingleton() { } 
    public static LazySingleton getInstance() { 
        //一重判断
        if (instance == null) {
            //锁定代码块
            synchronized (LazySingleton.class) {
                //二重判断
                if (instance == null) {
                    instance = new LazySingleton(); //创建单例实例
                }
            }
        }
        return instance; 
    }
}

使用双重检查锁，需要在静态成员变量instance之前增加修饰符volatile， volatile可以确保多个线程都能够正确处理，而且只能在JDK 1.5及以上版本中才能正确执行。但是 volatile关键字会屏蔽JVM所做的一些代码优化，这样就可能导致系统运行效率降低，因此即使使用双重检查锁定来实现单例模式也不是一种完美的实现方式。

接下来看最后一种终极模式Initialization Demand Holder (IoDH)：

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

没有可实例话的成员变量，因此类加载时不会实例化Singleton，第一次调用getInstance()时将加载内部类HolderClass，在该内部类中定义了一个static类型的变量instance，此时会首先初始化这个成员变量，由Java虚拟机来保证其线程安全性，确保该成员变量只能初始化一次。由于getInstance()方法没有任何线程锁定，因此其性能不会造成任何影响。

通过使用IoDH，既可以实现延迟加载，又可以保证线程安全，不影响系统性能，的确是最好的Java语言单例模式实现方式（其缺点是与编程语言本身的特性相关，很多面向对象语言不支持IoDH）。

最后，我们来总结一下单例模式的特点：

1.优点
       (1) 单例模式提供了对唯一实例的受控访问。因为单例类封装了它的唯一实例，所以它可以严格控制客户怎样以及何时访问它。
       (2) 由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。
       (3) 允许可变数目的实例。基于单例模式我们可以进行扩展，使用与单例控制相似的方法来获得指定个数的对象实例，既节省系统资源，又解决了单例单例对象共享过多有损性能的问题。

2.主要缺点
       (1) 由于单例模式中没有抽象层，因此单例类的扩展有很大的困难。
       (2) 单例类的职责过重，在一定程度上违背了“单一职责原则”。因为单例类既充当了工厂角色，提供了工厂方法，同时又充当了产品角色，包含一些业务方法，将产品的创建和产品的本身的功能融合到一起。
       (3) 现在很多面向对象语言(如Java、C#)的运行环境都提供了自动垃圾回收的技术，因此，如果实例化的共享对象长时间不被利用，系统会认为它是垃圾，会自动销毁并回收资源，下次利用时又将重新实例化，这将导致共享的单例对象状态的丢失。

3.适用场景
       (1) 系统只需要一个实例对象，如系统要求提供一个唯一的序列号生成器或资源管理器，或者需要考虑资源消耗太大而只允许创建一个对象。
       (2) 客户调用类的单个实例只允许使用一个公共访问点，除了该公共访问点，不能通过其他途径访问该实例。

《参考：确保对象的唯一性——单例模式》