设计模式之单例模式 - 杨玉杰|个人博客

单例模式的主要作用是保证在Java程序中，某个类只有一个实例存在，一些管理器和控制器常被设计成单例模式。

单例模式有许多好处：它能够避免实例对象的重复创建，不仅可以减少每次创建对象的时间开销，还可以节约内存空间，能够避免由于操作多个实例导致的逻辑错误，如果一个对象有可能贯穿整个应用程序，而且起到了全局统一管理控制的作用，那么单例模式也许是一个值得考虑的选择。

饿汉模式

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

类的构造函数定义为private的，保证其他类不能实例化此类，然后提供了一个静态实例并返回给调用者。

饿汉模式在类加载的时候就对实例进行创建，实例在整个程序周期都存在，它的好处是只在类加载的时候创建一次实例，不会存在多个线程创建多个实例的情况，避免了多线程同步的问题，它的缺点也很明显，即使这个单例没有用到也会被创建，而且在类加载之后就被创建，内存就被浪费了。

这种实现方式适合单例占用内存比较小，在初始化时就会被用到的情况，但是如果单例占用的内存比较大，或者单例只是在某个特定场景下才会用到，使用饿汉模式就不合适了。

懒汉模式

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

懒汉模式中单例是在需要的时候才去创建的，如果单例已经创建，再次调用获取接口将不会重新创建新的对象，而是直接返回之前创建的对象，如果某个单例使用的次数少，并且创建单例消耗的资源较多，那么就需要实现单例的按需创建，这个时候使用懒汉模式就是一个不错的选择，但是这里的懒汉模式并没有考虑线程安全问题，在多个线程可能会并发调用它的getInstance()方法，导致创建多个实例，因此需要加锁来解决线程同步问题。

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

双重校验锁

加锁的懒汉模式看起来既解决了线程并发问题，又实现了延迟加载，然而它存在着性能问题，依然不够完美，synchronized修饰的同步方法比一般方法要慢很多，如果多次调用getInstance()，累积的性能损耗就比较大了，因此就有了双重校验锁。

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

虽然双重校验锁既实现了延迟加载，又解决了线程并发问题，同时还解决了执行效率问题，但是仍存在问题。

这里要提到Java中的指令重排优化，所谓指令重排优化是指在不改变原语义的情况下，通过调整指令的执行顺序让程序运行更快。由于指令重排序的存在，导致初始化Singleton和将对象地址赋给Instance字段的顺序是不确定的，在某个线程创建单例对象时，在构造方法被调用之前，就为该对象分配了内存空间并将对向的字段设置为默认值，此时就可以将分配的内存地址赋值给Instance字段了，然而该对象可能还没有初始化，若紧接着另外一个线程来调用getInstance，取到的就是状态不正确的对象，程序就会出错。

解决办法：在Instance变量之前加volatile关键字

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

静态内部类

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

这种方式同样利用了类加载机制来保证只创建一个Instance实例，只要应用中不使用内部类，JVM就不会去加载这个单例类，也就不会创建单例对象，从而保证延迟加载和线程安全。

枚举

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

前面四种实现单例模式的方式都有共同的缺点：

需要额外的工作来实现序列化，否则每次反序列化一个序列化的对象时都会创建一个新的实例；
可以使用反射强行调用私有构造器

使用枚举除了线程安全和防止反射调用构造器外，还提供了自动序列化机制，防止反序列化的时候创建新的对象。