黑马程序员技术交流社区

标题: 关于懒汉式单例模式中同步锁使用的一个疑问 [打印本页]
作者: 陈君    时间: 2014-8-10 19:50
标题: 关于懒汉式单例模式中同步锁使用的一个疑问
本帖最后由 陈君 于 2014-8-10 20:21 编辑

下面先说下毕老师的写法：
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. {

  4. private static Single s=null;

  6. private Single(){}

  8. public static Single getInstance()

  10. {

  12. if(s==null)

  14. {

  16. synchronized(Single.class)

  18. {



  22. s=new Single();

  24. }

  26. }

  28. return s;

  30. }

  32. }
复制代码

  2. <P> </P>
复制代码

作者: 陈君    时间: 2014-8-10 19:54
好吧，我想通了，还是毕老师的好
作者: 陈云阳    时间: 2014-8-10 19:56
  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. }
复制代码


作者: weity    时间: 2014-8-10 20:02
楼上正解，道破天机。。。
作者: 不想飞不到    时间: 2014-8-11 00:23
恩 可能是synchronized的代价远大于if（s==null）产生的代价，如果只判断s==null就不用重复进synchronized再判断了
作者: a6511631    时间: 2014-8-11 08:37
这不是版主吗？版主你好！那个，其实网上有一种改进型的懒汉式。名为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方法并没有被同步，并且只是执行的一个域的访问，因此延迟初始化并没有增加任何访问成本。
版主再见！
作者: kakasa    时间: 2014-8-11 09:56
来学习了 。

懒汉 饿汉真很重要么，好多人纠结
作者: 陈君    时间: 2014-8-11 11:18
a6511631 发表于 2014-8-11 08:37
这不是版主吗？版主你好！那个，其实网上有一种改进型的懒汉式。名为Lazy initialization holder class。
...

我只是,net的版主
作者: 笑轻轻    时间: 2014-8-11 11:59
论坛真是高手多多啊又学习了




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2