谢谢
“问题已解决”

单例的3种模式
1懒汉式
private Single(){} private static Single s = null
public static Single getInstrance() {
  if(s==null)
   s=new Single;
  return s;
}
2饿汉式
private Single(){}
private static Single s = new Single();
public static Single getInstrance( {
  return s;
}
3 只有1个元素的枚举。
请问，这3种单例模式分别在什么情况下使用比较好啊，最好有极端的例子。

先看先看懒汉式

public class Singleton {  
    private static Singleton instance = null;  
    private Singleton(){  
        System.out.println(1);  
    }  
    synchronized public static Singleton getInstance(){  
        if(instance == null){  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}  

再看饿汉式

public class Singleton2 {  
    private static final Singleton2 instance = new Singleton2();  
    private Singleton2(){  
        System.out.println(2);  
    }  
    public static Singleton2 getInstance(){  
        return instance;  
    }  
}  

测试：

public class SingletonTest {  
    public static void main(String[] args){      
        //测试懒汉式   
        Singleton s11 = Singleton.getInstance();  
        Singleton s12 = Singleton.getInstance();         
        if(s11 == s12){  
            System.out.println("same singleton");  
        }else{  
            System.out.println("not same singleton");  
        }  
         
        //测试饿汉式   
        Singleton2 s21 = Singleton2.getInstance();  
        Singleton2 s22 = Singleton2.getInstance();        
        if(s21 == s22){  
            System.out.println("same singleton2");  
        }else{  
            System.out.println("not same singleton2");  
        }  
         
    }  
}  

输出结果

1  
same singleton  
2  
same singleton2  

分析，总结：

1，两种形式instance和构造方法都用private；

2，instance和getInstance()都用static；

3，饿汉式instance用final；

4，懒汉式getInstance()用synchronized才能保证线程安全；

5，饿汉式的instance定义时就初始化instance = new Singleton()，线程是安全的，且不论后期是否用到都初始化了，所以牺牲了资源利用率，一旦用到又将提高速度;

6，懒汉式的instance是在使用时才初始化的，所以提高了资源利用率，但是用到时会浪费速度；

7，尽量用饿汉式单例模式，简单、好用、安全。

总之，懒汉，恶汉，枚举。
恶汉：因为加载类的时候就创建实例，所以线程安全(多个ClassLoader存在时例外)。缺点是不能延时加载。
懒汉：需要加锁才能实现多线程同步，但是效率会降低。优点是延时加载。
枚举：很好，不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。但是失去了类的一些特性，没有延迟加载，用的人也太少了～～