JAVA单例模式

java单例大家都熟悉，下面总结几个简单例子

首先是经典单例模式：

/*
 * 经典单例模式
 */
public class SimpleInstance1 {
	private static SimpleInstance1 instance = null;
	private SimpleInstance1(){};
	public static SimpleInstance1 getInstance(){
		if (instance == null){
			return new SimpleInstance1();
		}
		else return instance;
	}
}

这种单例模式是在第一次调用getInstance的时候，对类进行初始化，以后调用时直接返回第一次初始化的实例。

但是这种模式不保证线程安全。例如，线程A和线程B同时第一次运行到如下语句

if (instance == null){

此时2个线程的判断都为true，所以就都进行了一次实例化new SimpleInstance1()。
为了避免这种线程不安全问题，可以使用饿汉式，如下：

/*
 * 饿汉一步到位方式
 */
public class SimpleInstance2 {
	private static final SimpleInstance2 instance = new SimpleInstance2();
	private SimpleInstance2(){};
	public static SimpleInstance2 getInstance(){
		return instance;
	}
}

上面把初始化放到了static中，这样在类装载的时候就进行了初始化，确实可以保证线程安全（因为真正开始调用getInstance()之前就已经初始化了），但是却丢失了部分系统资源。而且有一个明显的缺点，就是new SimpleInstance2()中，不能根据程序运行情况动态的往构造方法中传入参数。

现在我们回到最初的经典单例模式，为保证线程安全，我们做如下改进：

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

我们在getInstance方法中加入synchronized关键字，保证同一时刻只有一个线程可以进入此方法。这样确实可以保证线程安全，而且也是在真正需要用到此类的时候进行第一次初始化的，但是这样进行线程同步，性能开销很客观。

其实做出线程同步的目的，是防止首次初始化的时候出现线程不安全的情况，而上面的模式中，不仅首次初始化时要线程同步，即使初始化之后调用getInstance也进行线程同步限制了，不仅没必要，还浪费了时间。针对这种情况进行如下的改进：

/*
 * 双重锁定模式
 */
public class SimpleInstance4 {
	private volatile static SimpleInstance4 instance = null;
	private SimpleInstance4(){};
	public static SimpleInstance4 getInstance(){
		if (instance == null){
			synchronized (SimpleInstance4.class) {
				if (instance == null){
					return new SimpleInstance4();
				}
			}
		}
		return instance;
	}
}

这个不多解释了，只在初始化的那部分代码中加入线程同步，相比上面的那种同步小有改进。不过instance也被定义为volatile，因为new操作在jdk1.5以前不是一个规范安全的过程（具体可以参看jvm方面的资料），这样也消耗了不少系统时间。