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; www.zzzyk.com
}
}
这个不多解释了，只在初始化的那部分代码中加入线程同步，相比上面的那种同步小有改进。不过instance也被定义为volatile，因为new操作在jdk1.5以前不是一个规范安全的过程（具体可以参看jvm方面的资料），这样也消耗了不少系统时间。
补充：软件开发 , Java ,
