1. 在看视屏中，老师说单例模式中的懒汉式有一个重大的缺陷，但他一点而过，不解决。
   
2. 
   
3. //懒汉式:延迟加载方式。
   
4. class Single2{
   
5. private Single2(){}
   
6. private static Single2 s = null;
   
7. public static Single2 getInstance(){
   
8. if(s==null)
   
9. s = new Single2();
   
10. return s;
    
11. }
    
12. }
    
13. 
    
14. 当出现多线程访问时怎么解决，怎么解决安全问题？怎么解决效率低的问题？ 还有锁如何加?

复制代码

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

复制代码

你不仔细看视频

确实存在线程安全问题，搞上同步就行了......

1. class Single2{
   
2. private Single2(){}
   
3. private static Single2 s = null;
   
4. public synchronized static Single2 getInstance(){   //进行同步
   
5. if(s==null){
   
6.            if(s==null)                     //两步判断，执行效率高
   
7.          s = new Single2();         //运行原理，线程A 进入此线程代码区，判断，若为null,则实例化，执行完后，其他冻结状态的线程争夺cpu执行权，加入线程B 获取资源，判断
   
8.       }                                     // 经过第一个条件，若为null,则满足，然后进入第二个条件，这时候就不满足了，直接退出了。。。。
   
9.        return s;
   
10.     }
    
11. }

复制代码

if(s==null){
       if(s==null)    {                 //两步判断，执行效率高
.......
上面楼主从哪里的出这个结论的???

赵文 发表于 2013-1-21 14:48
确实存在线程安全问题，搞上同步就行了......

你这个两步判断一点用都没用，反而降低了效率，增加运行了一行代码，你的同步是定义在函数上的同步，每个线程调用该函数时，都要加锁，一点效率提升都没

柴乔军 发表于 2013-1-21 15:04
你这个两步判断一点用都没用，反而降低了效率，增加运行了一行代码，你的同步是定义在函数上的同步，每个 ...

{:2_41:}  谢谢提醒.....

yong230 发表于 2013-1-21 14:59
if(s==null){
       if(s==null)    {                 //两步判断，执行效率高
.......

确实，这样多了一行没任何意义的代码，效率低了，改成同步代码块，不过，谢谢提醒了...