单例模式和线程安全

//1.单例分两种: 
	  
	   //    饿汉式  和 懒汉式 
	  
	   // 饿汉式： 
	  
	   package com.chess.test;   
	        
	   /** 
	     *  
	     * 饿汉模式的单例 
	     * @author chess 
	     * 
	     */   
	    public final class SignleObjectHungry   
	    {   
	         
	        private static  SignleObjectHungry signleObjHun = new SignleObjectHungry();   
             
	        private SignleObjectHungry()   
	        {   
	                 
	        }   
	             
	        public static SignleObjectHungry getInstance()   
	        {   
	            return signleObjHun;   
	        }   
	             
	    }   
	   
	   
	   
	    // 懒汉式 
	   
	    package com.chess.test;   
	         
	    /** 
	     * 懒汉式单例模式 
	     * @author chess 
	     * 
	     */   
	    public final class SingleObjectLazy    
	    {   
	         
	        private static SingleObjectLazy signleObjLazy = null;   
	             
	        private SingleObjectLazy()   
	        {   
	                 
	        }   
	             
	        public static SingleObjectLazy getInstance()   
	        {   
	            if(null == signleObjLazy)   
	            {   
	                signleObjLazy = new SingleObjectLazy();   
	            }   
	            return signleObjLazy;   
	        }   
	             
	    }   
	   
	//  由于单例存在线程安全问题，所以要解决的话 
	   
	//  对于 
	   
	// 饿汉式线程安全 
	   
	    package com.chess.test;   
	         
	    /** 
	     * 饿汉式单例线程安全 
	     * @author chess 
	     * 
	     */   
	    public final class SingleObjectHungryAndThreadSafe    
	    {   
	         
	        private static SingleObjectHungryAndThreadSafe signleObj = new SingleObjectHungryAndThreadSafe();   
	             
	             
	        private SingleObjectHungryAndThreadSafe()   
	       {   
	                
	       }   
	            
	       /** 
	        * 加同步锁方法实现线程安全 
	        *  
	        * 此方法存在 性能开销 大 
	        *  
	        * @return 
	        */   
	       public synchronized static SingleObjectHungryAndThreadSafe getInstance()   
	       {   
	           return signleObj;   
	       }   
	    }   
	//懒汉式线程安全 
	   
	    package com.chess.test;   
	         
	    /** 
	     * 懒汉式单例 和 线程安全 
	     *  
	     * @author chess 
	     *  
	     */   
	    public final class SingleObjectLazyAndThreadSafe    
	    {   
	             
	        private static SingleObjectLazyAndThreadSafe singleObj = null;   
	         
	        private SingleObjectLazyAndThreadSafe()    
	        {   
	         
	        }   
	         
	        // public synchronized static SingleObjectLazyAndThreadSafe getInstance()   
	        // {   
	        //  if(null == singleObj)   
	        //  {   
	        //      singleObj = new SingleObjectLazyAndThreadSafe();   
	        //  }   
	        //         
	        //  return singleObj;   
	        //         
	        // }   
	         
	        // 细化粒度，提高性能 提高线程并发度   
	        //双重检查锁机制   
	        public static SingleObjectLazyAndThreadSafe getInstance()   
	        {   
	            if (null == singleObj)   
	            {   
	                synchronized (SingleObjectHungryAndThreadSafe.class)    
	                {   
	                    if (null == singleObj)    
	                    {   
	                        singleObj = new SingleObjectLazyAndThreadSafe();   
	                    }   
	                }   
	            }   
	         
	            return singleObj;   
	         
	        }   
	             
	        //至此 线程安全 已经感觉狠完美了。   
	        //多线程中，如果  线程A 执行到第 30 行，此时对象为空，则进入初始化对象,   
	        //      然而初始化对象需要时间,   
	        //   此时 线程B 也执行到第 30 行 , 此时对象已经初始化未完成, 但是地址已经存在。   
	        //   则 线程B 将获取一个未完成的 对象。   
	             
	    }   
	   
	   
	//完美的解决方案 
	   
	    package com.chess.test;   
	         
	         
	    /** 
	     * 单例模式线程安全的完美状态 
	     * 新的设计模式 
	     * 使用内部类   JLS会保证这个类的线程安全 
	     * (完全使用 JAVA 虚拟机的机制进行同步保证，且 没有同步的关键字) 
	     * @author chess 
	     * 
	     */   
	    public class SingleObjectThreadSafeNoSync    
	    {   
	        /** 
	         * 以内部类实现懒加载(懒汉) 
	         *  
	         * 初始化这个内部类的时候  JLS 保证这个类的线程安全 
	         * @author cWX181783 
	         * 
	         */   
	        private static class SingletonHolder   
	        {   
	            public final static SingleObjectThreadSafeNoSync singleObject = 
	                                                new SingleObjectThreadSafeNoSync();   
	        }   
	             
	        public static SingleObjectThreadSafeNoSync getInstance()   
	        {   
	            return SingletonHolder.singleObject;   
	        }   
	         
	    }