设计模式之单例设计模式（Singleton）

单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中只有一个对象实例存在。

单例模式和多例模式说明：

1）单例模式和多例模式属于对象模式。

2）单例模式的对象在整个系统中只有一份，多例模式可以有多个实例。（单例只会创建一次，而多例在程序运行中会创建多次）

3）不对外提供构造方法，即构造方法都是私有的。

好处：

1）某些类创建比较繁琐，对于一些大型的对象，这是一笔很大的系统开销。

2）省去new操作符，降低了系统内存的使用频率，减轻GC压力。

package com.usst.chicago;

public class Singleton {
	//私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载。
	private static Singleton instance = null;
	
	//私有构造函数，防止被实例化。
	private Singleton(){
	}
	
	//静态工程方法创建实例
	public static Singleton getInstance(){
		if(instance == null){
			instance = new Singleton();
		}
		return instance;
	}
	
	//如果该对象被用于序列化，可以保证对象在序列化前后保持一致。
	public Object readResolve(){
		return instance;
	}

}

这个类可以满足基本要求，但是，像这样毫无线程安全保护的类，如果放到多线程的环境下，肯定会出现问题。

分析一下：线程A使用Singleton时，调用getInstance方法。因为是第一次调用，instance为null，于是开始创建实例。此时CPU发生时间片切换，线程B开始执行，它要使用Singleton，调用getInstance方法，同样检测到instance为null。注意：这是在A检测之后切换，而A没有来得及创建对象。因为B开始创建，B创建完成后，切换到A继续执行。因为它已经检测完成，所以A不会再检测一遍，它会直接创建对象。这样，线程A和B各自拥有一个Singleton对象，单例失败！如何解决呢？

首先会想到对getInstance方法加synchronized关键字。

//静态工程方法创建实例
	public static synchronized Singleton getInstance(){
		if(instance == null){
			instance = new Singleton();
		}
		return instance;
	}

但是，synchronized关键字锁住的是这个对象。这样在性能上会有所下降，因为每次调用getInstance方法都要对对象上锁，如果存在很多次getInstance的调用，那么性能问题就不得不考虑了。事实上， 只有在第一次创建对象的时候需要加锁，之后就不需要了。所以，需要改进，将检测null的操作和创建对象的操作分离，如果这两个操作能够原子的进行，那么单例就可以保证了。

//静态工程方法创建实例
	public static Singleton getInstance(){
		if(instance == null){
			synchronized(instance){
				if(instance == null){
					instance = new Singleton();
				}
			}
		}
		return instance;
	}

似乎解决了之前的问题。 将synchronized关键字放在内部，也就是说当调用时不需要加锁，只有在instance为null，并且创建对象时才需要加锁，性能有一定的提升。但是这样的情况还有可能有问题： 在Java中创建对象和赋值操作是分开进行的，也就是说instance = new Singleton(); 语句分两步执行。但是JVM并不保证两个操作的先后顺序，也就是说有可能JVM会为新的Singleton实例分配空间，然后直接赋值给instance成员，最后再去初始化这个Singleton实例。这样可能出错，以A、B线程为例。

>A、B线程同时进入第一个判断

>A首先进入synchronized块，由于instance为null，所以它执行instance = new Singleton();

>由于JVM内部的优化机制，JVM划分一些分配给Singleton实例的内存，并赋值给instance成员（此时JVM没有开始初始化实例），然后A离开synchronized块。

>B进入synchronized块，由于instance此时不是null，因此它马上离开synchronized块并将结果返回给调用该方法的程序。

>此时B线程打算使用Singleton实例，却发现它没有被初始化，于是错误发生。

进一步优化。单例模式使用内部类来维护单例的实现，JVM内部的机制能够保证当一个类被加载时，这个类的加载过程是线程互斥的。这样当第一次调用getInstance时，JVM能保证instance只被创建了一次，并且保证把赋值给instance的内存初始化完毕，这样就不用担心上面的问题。此方法也只会在第一次调用的时候使用互斥机制，解决了低性能的问题。

package com.usst.chicago;

public class Singleton {
	
	//私有构造函数，防止被实例化。
	private Singleton(){
	}
	
	//使用内部类维护单例
	private static class SingletonFactory{
		private static Singleton instance = new Singleton();
	}
	
	//获取实例
	public static Singleton getInstance(){
		return SingletonFactory.instance;
	}
	
	
	//如果该对象被用于序列化，可以保证对象在序列化前后保持一致。
	public Object readResolve(){
		return getInstance();
	}

}

此代码也不一定就是很完美，我们只能根据实际情况，选择最适合自己应用场景的实现方法。如下实现：因为只需要在创建类时同步，所以只要将创建和getInstance()分开，单独为创建加synchronized关键字。

package com.usst.chicago;

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

}

单例模式总结：

1）单例模式理解起来简单，但是具体实现起来有一定难度。

2）synchronized关键字锁定的是对象。使用时，一定要在恰当的地方使用（注意需要使用锁的对象和过程，可能并不是整个对象或整个过程都需要锁）。

使用类的静态方法实现单例模式的效果也是可行的。静态类和类的静态方法二者有什么不同？

首先，静态类不能实现接口。

其次，单例类可以被延迟初始化，静态类一般在第一次加载时初始化。之所以延迟加载，是因为有些类比较庞大，延迟加载有助于提升性能。

再次，单例类可以被继承，方法可以被覆写。但是静态类内部方法都是static，无法被覆写。

最后，单例类比较灵活，毕竟从实现上只是一个普通的Java类，只要满足单例的基本需求，可以在里面实现一些其他功能，但是静态类不行。

二者有很大的关联，只是考虑问题的层面不同罢了。两种思想结合，才能造就出完美的解决方案。其实生活中很多事情都是这样那样，单用不同的方法来处理问题，总是有优点也有缺点，最完美的方法是结合各个方法的优点，才能最好的解决问题！