java单例设计模式实例总结

package ff;


public class singleton {
public static void main(String args[]){
single1 s11=single1.getInstance();
single1 s12=single1.getInstance();
single2 s21=single2.getInstance();
single2 s22=single2.getInstance();
single3 s31=single3.getInstance();
single3 s32=single3.getInstance();
single4 s41=single4.getInstance();
single4 s42=single4.getInstance();
Single5 s51=Single5.getInstance();
Single5 s52=Single5.getInstance();
System.out.println(s12==s11);
System.out.println(s22==s21);
System.out.println(s32==s31);
System.out.println(s42==s41);
System.out.println(s52==s51);

}
}
/*
 * 单线程的单例模式。若有两个线程，同时执行到if语句，因此都会创建s1，则违背单例原则，懒汉式(调用方法时候创建)
 */
class single1{
private single1(){

}
private static single1 s1;
public static single1 getInstance(){
if(s1==null){
s1=new single1();
}
return s1;
}
}
/*
 * 所有想获取实例的都要加锁，加锁解锁是比较耗时的，懒汉式
 */
class single2{
private single2(){

}
private static single2 s2;
public static single2 getInstance(){
synchronized(single2.class){
if(s2==null){
s2=new single2();
}
}
return s2;
}
}
/*
 * 只有同时争夺s3，且s3位空时才会加锁，锁数目明显减少。但看起来比上个复杂，使用到了两个嵌套if来判断。懒汉式
 */
class single3{
private single3(){

}
private static single3 s3;
public static single3 getInstance(){
if(s3==null){
synchronized (single3.class) {
if(s3==null){
s3=new single3();
}
}
}
return s3;
}
}
/*
 * 利用静态对象只可以被创建一次的特性。代码也十分的简洁，实例创建在使用到single4类时，过早。饿汉式（使用到类时创建）
 */
class single4{
private single4(){

}
private static single4 s4=new single4();
public static single4 getInstance(){
return s4;
}
}
/*
 * 私有类的属性私有，其他人无法使用它的属性。当我们第一次试图得到实例时才会创建。懒汉式
 */
class Single5 {  
 
    private static class Single3Holder {  
        private static final Single5 INSTANCE = new Single5();  
    }  
  
    private Single5() {  
    }  
  
    public static Single5 getInstance() {  
        return Single3Holder.INSTANCE;  
    }  
  
}