struts单例模式 java_JAVA单例模式

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同时第一次运行到如下语句

[java]

if (instance == null){

此时2个线程的判断都为true，所以就都进行了一次实例化new SimpleInstance1()。

为了避免这种线程不安全问题，可以使用饿汉式，如下：

[java]

/*

* 饿汉一步到位方式

*/

public class SimpleInstance2 {

private static final SimpleInstance2 instance = new SimpleInstance2();

private SimpleInstance2(){};

public static SimpleInstance2 getInstance(){

return instance;

}

}

上面把初始化放到了static中，这样在类装载的时候就进行了初始化，确实可以保证线程安全(因为真正开始调用getInstance()之前就已经初

始化了)，但是却丢失了部分系统资源。而且有一个明显的缺点，就是new

SimpleInstance2()中，不能根据程序运行情况动态的往构造方法中传入参数。

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

[java]

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也进行线程同步限制了，不仅没必要，还浪费了时间。针对这种情况进行如下的改进：

[java]

/*

* 双重锁定模式

*/

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方面的资料)，这样也消耗了不少系统时间。