下面先说下毕老师的写法：
class Single
{
      private static Single s=null;
      private Single(){}
      public static Single getInstance()
     {
            if(s==null)
           {
                 synchronized(Single.class)
                 {
                       if(s==null)
                      s=new Single();
                 }
           }
          return s;
     }
}
我觉得我这样写的话会更好吧：

1. class Single
   
2. {
   
3. 
   
4. private static Single s=null;
   
5. 
   
6. private Single(){}
   
7. 
   
8. public static Single getInstance()
   
9. 
   
10. {
    
11. 
    
12. if(s==null)
    
13. 
    
14. {
    
15. 
    
16. synchronized(Single.class)
    
17. 
    
18. {
    
19. 
    
20. 
    
21. 
    
22. s=new Single();
    
23. 
    
24. }
    
25. 
    
26. }
    
27. 
    
28. return s;
    
29. 
    
30. }
    
31. 
    
32. }
    

复制代码

1. 
   
2. <P> </P>

复制代码

好吧，我想通了，还是毕老师的好

1. class Single
   
2. {
   
3.       private static Single s=null;
   
4.       private Single(){}
   
5.       public static Single getInstance()
   
6.      {
   
7.             if(s==null)
   
8.            { 假设A  B两个线程执行到这里，A先进去了
   
9.                  synchronized(Single.class)
   
10.                  {
    
11. //if(s==null)//如果这里被注释， A创建完出来，B进来就会又创建了对象，所以这一行千万不能省，
    
12.                       s=new Single();
    
13.                  }
    
14.            }
    
15.           return s;
    
16.      }
    
17. }

复制代码

楼上正解，道破天机。。。

恩 可能是synchronized的代价远大于if（s==null）产生的代价，如果只判断s==null就不用重复进synchronized再判断了

这不是版主吗？版主你好！那个，其实网上有一种改进型的懒汉式。名为Lazy initialization holder class。
这种延迟加载的代码示例如下：

1. public class Singleton {  
   
2.     /**
   
3.      * 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例
   
4.      * 没有绑定关系，而且只有被调用到才会装载，从而实现了延迟加载
   
5.      */  
   
6.     private static class SingletonHolder{  
   
7.         /**
   
8.          * 静态初始化器，由JVM来保证线程安全
   
9.          */  
   
10.         private static Singleton instance = new Singleton();  
    
11.     }  
    
12.     /**
    
13.      * 私有化构造方法
    
14.      */  
    
15.     private Singleton(){  
    
16.     }  
    
17.     public static  Singleton getInstance(){  
    
18.         return SingletonHolder.instance;  
    
19.     }  
    
20. }

复制代码

这个解决方案的优势在于：getInstance方法并没有被同步，并且只是执行的一个域的访问，因此延迟初始化并没有增加任何访问成本。
版主再见！

来学习了 。

懒汉 饿汉真很重要么，好多人纠结

a6511631 发表于 2014-8-11 08:37
这不是版主吗？版主你好！那个，其实网上有一种改进型的懒汉式。名为Lazy initialization holder class。
...

我只是,net的版主

论坛真是高手多多啊又学习了