懒汉式有什么弊端，怎么避免呢？

1. class Single
   
2. {
   
3.         private static Single s = null;
   
4.         private Single(){}
   
5.         public static Single getInstance()
   
6.         {
   
7.                 if(s==null)
   
8.                 {
   
9.                         synchronized(Single.class)
   
10.                         {                               
    
11.                                 if(s==null)
    
12.                                         s = new Single();
    
13.                         }
    
14.                 }
    
15.                 return s;
    
16.         }
    
17. }
    
18. 
    
19. //定义单例，建议使用饿汉式。
    
20. //简单，容易记下，还不容易发生问题
    
21. 
    
22. 
    
23. 
    
24. 
    
25. class Single
    
26. {
    
27.         private static Single s = new Single();
    
28.         private Single(){}
    
29.         public static Single getInstance()
    
30.         {
    
31.                 return s;
    
32.         }
    
33. }
    

复制代码

tangxiaobo1991 发表于 2014-3-10 00:49
晕，没看毕姥爷的视频吗？？？他老人家强调了好多次阿，亲！！！；懒汉式可以提高运行效率，在没有调用时不 ...

哈哈 哥们儿略激动 不过锁太多的话有可能造成死锁哦 这个我看上面都没有提到过:lol

晕，没看毕姥爷的视频吗？？？他老人家强调了好多次阿，亲！！！；懒汉式可以提高运行效率，在没有调用时不会加载对象，只有在调用对象时才会创建并调用对象！！但这也有一个问题，那就是遇到多线程时会遇到安全问题，因此可以采用两个if判断的方式来避免这种情况！！代码如下
     class Single {
        private static  Single s=null;
        Object obj=new Object();//上帝嘛，你懂的
        private Single(){}
        public  Single getInstance()
             {
                if (s==null)
                       {
                        synchronized (obj)
                            {
                                if (s==null)
                                       s=new Single();
                           }
                   }
                   return s;
        }
}

所谓的单例就是一个类只能创建一个实例 所谓懒汉模式就是说不管你是否来取实例，我都一早给你创建好，等你来取 所谓饿汉模式就是说之前不一定已经创建好实例，你来取实例的时候我先检查是否存在实例，存在就返回给你，不存在就new一个给你

懒汉式的弊端就是线程安全问题，如果要避免有两种方法：
1.在获取对象的方法中加入synchronized
2.双重判断。并在第二重判断中加入synchronized。

懒汉式单例，存在线程安全问题，可以加同步synchronized来解决，但是同步带来效率下降，在懒汉式单例中再加个if判断可以提高了同步带来的效率低问题，代码如下：

1. public class Single {
   
2.         private static  Single s=null;
   
3.         private Single(){}
   
4.         public static Single getInstance(){
   
5.                 if (s==null) {
   
6.                         synchronized (Single.class) {
   
7.                                 if (s==null)
   
8.                                         s=new Single();
   
9.                         }
   
10.                 }
    
11.                 return s;
    
12.         }
    
13. }

复制代码

syw02014 发表于 2014-3-8 09:33
饿汉式单例

优点：没有加锁，执行效率会提高。

明白了，谢谢

懒汉式中有对象的延时加载，可能不同的线程会在等待唤醒期间建立多个对象，这不符合单例设计模式。可以加同步synchronized来解决，加同步时用的锁是该类所属的字节码文件对象，但是当线程很多时，每个线程都要判断锁，所以懒汉式在运行时比较低效。可以用双重判断的方式来解决问题，第一次判断后，以后进来的线程都不用判断了，会稍微提高效率。即

1. class Single{
   
2.      private static Single s = null;
   
3.      private Single() {}
   
4.      public static Single getInstance(){
   
5.            if(s==null)
   
6.            {
   
7.                   synchronized(Single.class)
   
8.                   {
   
9.                          if(s==null)
   
10.                               s=new Sinlge();
    
11.                    }
    
12.             }
    
13.       }
    
14. }

复制代码

问题应该说清楚点。懒汉式跟饿汉式的区别在与对象是否加载，取决于是否使用。硬要说弊端就是在使用时才会有对象。

饿汉式单例

1. public class Singleton
   
2. {
   
3.       private static final Singleton SINGLETON = new Singleton();
   
4.       private Singleton() {} //此类不能被实例化
   
5.       public static synchronized Singleton getInstance() {
   
6.       return SINGLETON;
   
7. }

复制代码

优点：没有加锁，执行效率会提高。
缺点：类加载时就初始化，浪费内存。
饿汉式无需关注多线程问题、写法简单明了、能用则用。但是它是加载类时创建实例（上面有个朋友写错了）、所以如果是一个工厂模式、缓存了很多实例、那么就得考虑效率问题，因为这个类一加载则把所有实例不管用不用一块创建。懒汉式的优点是延时加载、缺点是应该用同步（想改进的话现在还是不可能，比如double-check）、其实也可以不用同步、看你的需求了，多创建一两个无引用的废对象其实也没什么大不了。

当遇到线程时  有可能不是单例模式啦   应该是代码同步  在方法上加synchronized 不是最佳的方法  下面是最佳的方法  双重判断

1. public class Single2 {  
   
2.       private static Single2 ss = null;  
   
3. private Single2(){  
   
4.     }  
   
5.     public static Single2 getIntance(){  
   
6.         if(ss == null){  
   
7.             synchronized(Single2.class){  
   
8.                 if(ss==null){  
   
9.                     ss = new Single2();  
   
10.             }  
    
11.                   
    
12.       }  
    
13.               
    
14.        }  
    
15.            return ss;  
    
16.     }  
    
17. }

复制代码

就是同步问题，   如果多个线程获取对象，可能会获取不同的引用。  对获得对象的方法加上synchronized  保证不会出现不同的引用