设计模式之一——单例模式（Java）

1. 概述

单例设计模式是一种对象创建模式，用于产生一个对象的具体实例，它可以确保系统中一个类只产生一个实例，最经典的莫过于其私有化的构造函数。

优点：

对于频繁使用的对象，可以省略创建对象所花费的时间，这对于那些重量级对象而言，是非常可观的一笔系统开销。
由于new操作的次数减少，因而对系统内存的使用频率也会降低，这将减轻GC压力，缩短GC停顿时间。

2. 饿汉式

饿汉式单例模式就是在类加载的时候就立即初始化，并且创建单例对象。不管你有没有用到，都先建好了再说。它绝对线程安全，在线程还没出现以前就实例化了，不可能存在访问安全问题。
步骤：

1. 私有化构造函数。
2. 声明本类的引用类型变量，并且使用该变量指向本类对象。
3. 提供一个公共静态的方法获取本类的对象。

public class HungrySingleton {
	//声明本类的引用类型变量，并且使用该变量指向本类对象
	private static final HungrySingleton instance = new HungrySingleton();
	//私有化构造函数
	private HungrySingleton(){
		System.out.println("instance is created");
	}
	//提供一个公共静态的方法获取本类的对象
	public static HungrySingleton getInstance(){
		return instance;
	}
}

优缺点：饿汉式单例模式就是在类加载的时候就立即初始化，并且创建单例对象。不管你有没有用到，都先建好了再说。它绝对线程安全，在线程还没出现以前就实例化了，不可能存在访问安全问题。
优点：线程安全，没有加任何锁、执行效率比较高。
缺点：类加载的时候就初始化，不管后期用不用都占着空间，浪费了内存。

3. 懒汉式

懒汉式，顾名思义就是实例在用到的时候才去创建，“比较懒”，用的时候才去检查有没有实例，如果有则直接返回，没有则新建。

3.1 版本一

步骤：

1. 私有化构造函数。
2. 声明本类的引用类型变量，但是不要创建对象。
3. 提供公共静态的方法获取本类的对象，获取之前先判断是否已经创建了本类对象，如果已经创建了，那么直接返回对象即可，如果还没有创建，那么先创建本类的对象，然后再返回。

public class LazySingleton {
	//声明本类的引用类型变量，不创建本类的对象
	private static LazySingleton instance;
	//私有化构造函数
	private LazySingleton(){
		
	}
	public static LazySingleton getInstance(){
		//第一次调用的时候会被初始化
		if(instance == null){
			instance = new LazySingleton();
		}
		return instance;
	}
}

优缺点：版本一这种写法有一定概率会生成不同的对象，意味着这种写法不是线程安全的。原因如下：
假如有两个线程，线程A和线程B同时走到“if(instance== null)”这个判断，因为instance还没有没实例化过，所以两个线程判断的结果都是true，然后同时进入 if 代码块执行 new 操作，这时，线程A创建了一个实例，线程B也创建了一个实例，最后 return 的 lazy 肯定不是同一个对象，所以，这种写法是线程不安全的。

3.2 版本二

public class LazySafetySingleton {
	
	private static LazySafetySingleton instance = null;
	private LazySafetySingleton(){
		
	}
	
	//同步代码块实现
	public synchronized static LazySafetySingleton getInstance(){
		if(instance == null){
			instance = new LazySafetySingleton();
		}
		return instance;
	}
}

优缺点：由于我们给该方法加上了 synchronized 锁，所以当线程A进入 getInstance() 方法的时候，线程B就只能在方法外等到线程A执行完这个方法之后才能进入该方法。由于线程A已经执行完该方法，所以此时 instance是不为null的，线程B就不会进入 if 代码块，最后返回的肯定是线程A创建的实例。

3.3 版本三（DCL双检锁）

版本二这种方式成功解决了线程安全问题，但在线程数量比较多的情况下，大量线程会阻塞在方法外部，导致程序性能下降。为了兼顾性能和线程安全问题，我们可以通过双重检查锁的方式来创建懒汉式的单例：

public class DclSingleton {
	
	private static volatile DclSingleton instance = null;
	
	private DclSingleton(){
		
	}
	public static DclSingleton getInstance(){
		//避免不必要的同步
		if(instance == null){
			//同步
			synchronized (DclSingleton.class) {
				//在第一次调用时初始化
				if(instance == null){
					instance = new DclSingleton();
				}
			}
		}
		return instance;
	}

}

注意：

• 在if判断中执行的instance = new DclSingleton()，该操作不是一个原子操作，JVM首先会按照逻辑，第一步给instance分配内存；第二部，调用DclSingleton()构造方法初始化变量；第三步将instance对象指向JVM分配的内存空间；JVM的缺点：在即时编译器中，存在指令重排序的优化，即以上三步不一定会按照顺序执行，就会造成线程不安全。
• 给instance的声明加上volatile关键字，volatile能保证线程在本地不会存有instance的副本，而是每次都到内存中读取。即禁止JVM的指令重排序优化。即按照原本的步骤。把instance声明为volatile之后，对它的写操作就会有一个内存屏障，这样，在它的赋值完成之前，就不会调用读操作。

3.4 版本四（静态内部类）

public class StaticInnerSingleton {
	
	private StaticInnerSingleton(){
		
	}
	/**
	 * 在第一次加载StaticInnerSingleton时不会初始化instance，
	 * 只在第一次调用了getInstance方法时，JVM才会加载StaticInnerSingleton并初始化instance
	 * @return
	 */
	public static StaticInnerSingleton getInstance(){
		return SingletonHolder.instance;
	}
	//静态内部类
	private static class SingletonHolder{
		private static final StaticInnerSingleton instance = new StaticInnerSingleton();
	}

}

优缺点：JVM提供了同步控制功能：static final，利用JVM进行类加载的时候保证数据同步。在内部类中创建对象实例，只要应用中不使用内部类，JVM就不会去加载该类，就不会创建我们要创建的单例对象，这种方式兼顾了饿汉式单例模式的内存浪费问题和 synchronized 的性能问题。内部类一定是要在 方法调用之前初始化，巧妙地避免了线程安全问题。

3.5 版本五（枚举）

public enum EnumSingleton {
	//定义一个枚举的元素，它就是Singleton的一个实例
	INSTANCE;
	
	public void doSomething(){
		
	}
}

优缺点：写法简单，线程安全
注意：如果在枚举类中有其他实例方法或实例变量，必须确保是线程安全的。