线程安全的单例类

    单例模式中，有两种实现，一种是饥饿模式，另一种是懒汉模式。
    饥饿模式的实现：

public final class EagerSingleton  {  
    private static EagerSingleton instance = new EagerSingleton();        
    
    private EagerSingleton(){  
    }  
	  
    public static EagerSingleton getSingleInstance(){  
        return instance；
    }  
}  

    优点：线程安全
    缺点：未使用该对象的时候，已经加载到了内存，但对象很大的时候是一种浪费

    懒汉模式的基本实现：

public final class LazySingleton {  
    private static LazySingleton instance = null;  
	  
    private LazySingleton(){  
    }  
	  
    public static LazySingleton getSingleInstance(){  
        if(null == instance ) {
	    instance = new LazySingleton();
	}
	eturn instance；
    }  
}  

    优点：延迟加载，按需分配内存
    缺点：线程不安全，如果两个线程同时第一次访问getInstance方法，则会生成两份实例。
   
    为了解决懒汉模式的线程安全问题，第一种解决方法是在getInstance方法前加入synchronized修饰。

public final class LazySingleton {  
    private static LazySingleton instance = null;  
	  
    private LazySingleton(){  
    }  
	  
    public static synchronized LazySingleton getSingleInstance(){  
        if(null == instance ) {
	    instance = new LazySingleton();
	}
	eturn instance；
    }  
}  

   
    第一种方法可以解决线程安全问题，但使用synchronized同步必将降低性能，所以可以考虑将同步的粒度降低，所以有了第二种解决方法。

public final class DoubleCheckedSingleton {  
    private static DoubleCheckedSingleton instance = null;  
	  
    private DoubleCheckedSingleton(){  
    }  
	  
    public static DoubleCheckedSingleton getSingleInstance(){  
        if(instance == null ) {
            Synchronized(DoubleCheckedSingleton.class){
                if(instance == null){
	            instance = new DoubleCheckedSingleton();
                }
	    }
	}
	return instance；
    }  
}  

    第二种解决方法，实现了线程安全，同时也将同步的粒度降低到代码块中，提高了性能。但第二种解决方法是用双重检查锁来实现，这种做法是不推荐使用的。
    那么就有了第三种解决方法，使用内部类来延迟加载，在类的加载过程中会保证线程的安全。

public class Singleton {    
    private static class SingletonHolder {    
        public final static Singleton instance = new Singleton();    
    }    
	   
    public static Singleton getInstance() {    
        return SingletonHolder.instance;    
    }    
}