单例模式和线程安全
单例模式和线程安全
lee123lee 发表于4年前
单例模式和线程安全
  • 发表于 4年前
  • 阅读 260
  • 收藏 1
  • 点赞 0
  • 评论 0

【腾讯云】如何购买服务器最划算?>>>   

//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;    
        }    
         /**
     * Java正则表达式判断字符串是否包含中文
     * @param str 待测字符串
     * @return 是否包含中文
     */
    public static boolean isContainChinese(String str) {
        if (null == str || "".equals(str.trim())) {
            return false;
        }
        Pattern p=Pattern.compile("[\u4e00-\u9fa5]");
        Matcher m=p.matcher(str);
        if(m.find()) {
            return true;
        }
        return false;
        }

    }
标签: Java 单例模式
共有 人打赏支持
粉丝 50
博文 136
码字总数 122159
作品 1
×
lee123lee
如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!
* 金额(元)
¥1 ¥5 ¥10 ¥20 其他金额
打赏人
留言
* 支付类型
微信扫码支付
打赏金额:
已支付成功
打赏金额: