Java设计模式之单例模式

单例模式(Singleton Pattern)：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。单例模式是一种对象创建型模式。

单例模式有三个要点：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。

对单例的实现可以分为两大类------懒汉式和饿汉式，他们的区别在于：

懒汉式：指全局的单例实例在第一次被使用时构建。

饿汉式：指全局的单例实例在类装载时构建。

从它们的区别也能看出来，日常我们使用的较多的应该是懒汉式的单例，毕竟按需加载才能做到资源的最大化利用。

懒汉式单实例：

java 复制代码

public class Singleton {
	//volatile的作用是内存可见性和禁止指令重排序
    private static volatile Singleton instance;

	//禁止在类的外部通过new关键字创建实例
    private Singleton() {}

	//对外部提供获取实例的接口
    public static Singleton getInstance() {
		//第一次检查，只有当实例没有被创建时才进入同步代码块
        if (instance == null) {
			//在多线程情况下，同步代码块保证只能有一个线程可以创建实例
            synchronized (Singleton.class) {
				//第二次检查，只有当实例没有被创建时，才创建实例
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

在执行instance = new Singleton();这句代码时，底层是分三个指令来完成的，对应的操作分别是：1.在堆内存中给Singleton分配内存空间；2.对Singleton进行初始化；3.在栈中创建一个引用变量instance，并将Singleton实例在堆内存中的地址值赋值给instance，即instance指向了new Singleton()实例。由于CPU在执行指令时，为了提高执行效率，会对指令进行重排序优化，所以上面三个指令的执行顺序可能是1->3->2。假设线程1按照1->3->2的顺序执行实例的初始化操作，当线程1执行到1->3时，即instance指向了Singleton实例，但是此时Singleton实例还未被初始化，而instance的值已经不为null了。然后CPU剥夺了线程1的执行权，紧接着线程2通过getInstance方法来获取实例，当执行if (instance == null)时，发现instance不为null了，就直接返回instance了，并使用instance，由于Singleton实例还未被初始化(类的静态变量都未被赋值)，使用Singleton实例就会报错。对instance变量加上volatile修饰符之后，就可以禁止指令重排序，同时保证该变量具有内存可见性。在该变量被同步回主内存之前，其他线程是不能对该变量进行读取的。所以，加上volatile关键字就可以避免上述问题的发生。

为什么要判空两次？

第一次判空：假设有个线程进入同步代码块创建对象成功，在释放锁退出同步代码块时，CPU执行权被剥夺了，此时instance已经不为空了。恰好此时第二个线程创建对象，通过第一次判空发现instance不为空，则直接返回instance对象，就无需等待获取锁进入同步代码块。

第二次判空：假设有个线程进入同步代码块创建对象，在执行instance = new Singleton();之前被剥夺了CPU执行权，此时instance依然是null。恰好此时第二个线程想要创建对象，通过第一次判空发现instance为空，则尝试获取锁，但是锁对象依然被第一个线程持有，所以第二个线程进入等待状态。当第一个线程重新获得CPU执行权，并创建对象退出同步代码块之后，此时instance不为空了。接着第二个线程获得CPU执行权并尝试获取锁，获取锁成功之后，进入同步代码块尝试创建对象。如果此处不判断instance是否为null，则还会再次创建一个对象，此时就不是单例对象了。所以需要两次判空。

懒汉式单实例的缺点是写法有些复杂，不够优雅、简洁。

饿汉式单实例：

java 复制代码

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

饿汉式单实例的缺点是：由于INSTANCE的初始化是在类加载时进行的，而类的加载是由ClassLoader来做的，所以开发者本来对于它初始化的时机就很难去准确把握，可能由于初始化的太早，造成资源的浪费。如果初始化本身依赖于一些其他数据，那么也就很难保证其他数据会在它初始化之前准备好。

其他的实现方式：

1、静态内部类的方式

java 复制代码

// Effective Java 第一版推荐写法
public class Singleton {
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
	
    private Singleton (){}
	
    public static final Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

这种写法的优点是：对于内部类SingletonHolder，它是一个饿汉式的单例实现，在SingletonHolder初始化的时候会由ClassLoader来保证同步，使INSTANCE是一个真单例。同时，由于SingletonHolder是一个内部类，只在外部类Singleton的getInstance()中被使用，所以它被加载的时机也就是在getInstance()方法第一次被调用的时候。

这种方式利用了ClassLoader来保证了同步，同时又能让开发者控制类加载的时机。从内部看是一个饿汉式的单例，但是从外部看来，又的确是懒汉式的实现。

2、枚举的方式：

java 复制代码

// Effective Java 第二版推荐写法
public enum SingleInstance {
    INSTANCE;
    public void fun1() { 
        // do something
    }
}
// 在其他类中使用
SingleInstance.INSTANCE.fun1();

由于创建枚举实例的过程是线程安全的，所以这种写法也没有同步的问题。

作者对这个方法的评价：这种写法在功能上与共有域方法相近，但是它更简洁，无偿地提供了序列化机制，绝对防止对此实例化，即使是在面对复杂的序列化或者反射攻击的时候。虽然这种方法还没有广泛采用，但是单元素的枚举类型已经成为实现Singleton的最佳方法。

枚举单例这种方法问世以后，许多分析文章都称它是实现单例的最完美方法------写法超级简单，而且又能解决大部分的问题。