线程安全的单例模式 的各种实现 总结

第一种：饿汉式

public class EagerSingleton {

          private static EagerSingleton instance = new EagerSingleton(); 

         private EagerSingleton(){};

         public static EagerSingleton getInstance(){
            return instance;
        }
}

第二种：懒汉式同步整个getInstance

public class ThreadSafeSingelton{
	//variables and constructors...
	//多线程并发时效率低下
	public static   synchronized   ThreadSafeSingelton getInstance(){
		
		if(instance == null){
			instance = new ThreadSafeSingelton();
		}
		retrun instance;
	}
}

第三种：Doublle-Check Locking

public class DoublleCheckSingleton{
	private volatile static DoublleCheckSingleton instance = null;
	
	//constructors
	
	public static DoublleCheckSingleton getInstance(){
		if(instance = null){//check if it is created
			 synchronized ( DoublleCheckSingleton.class) {
				//synchronize creation block
				if(instance ==null) //double check if it is created
					instance = new DoublleCheckSingleton();
			} 
			
		}
		
		retrun instance;
	}
}

Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

第四种：内部类 Initialization on demand holder

	public class LazyLoadedSingleton{
		private LazyLoadedSingleton (){
		}
		
		 private static class LazyHolder { //holds the singleton class
			private static final LazyLoadedSingleton singletonInstance = new LazyLoadedSingleton();
		} 
		
		public static LazyLoadedSingleton getInstance() {
			return LazyHolder.singletonInstance;
		}
	}

JLS保证 JVM加载 LazyHolder时不会出现并发问题。

****防止反序列化

public class SerialibleSingleton implements Serialible {
	private static final long serialVersionUID = -609961712631545485L;
	static SerialibleSingleton singleton = new SerialibleSingleton();
	
	private SerialibleSingleton(){}
	
	 private Object readResole(){
		return singleton;
	} 
} 

第五种：枚举单例模式

public   enum   Sington{
    
      INSTANCE;

     public void singletonOpr(){
      
      // some opertions 

     }

}