黑马程序员技术交流社区

标题: 单例设计模式中的小问题！ [打印本页]
作者: hejinzhong    时间: 2014-7-20 18:16
标题: 单例设计模式中的小问题！
  1. 单例设计模式
  2. （1）饿汉式
  3. class Single
  4. {
  5.            private static final Single s = new Single();
  6.            private Sinle(){｝
  7.            public static Single getInstance()
  8.            {
  9.                    return s;
  10.            }
  11. }（2）懒汉式
  12. class Single
  13. {
  14.             private static Single s = new Single();
  15.             private Single(){}
  16.             public static Single getInstance()
  17.             {
  18.                       if(s==null)//这里判断为空的话，就会去检测锁，每次只能进去一个。
  19.                       {
  20.                                 Synchronized(Single.class)
  21.                                  {
  22.                                          if(s==null)//这里有必要判断为空吗？能进来锁，就代表他是来创建对象的，何必再判断
  23.                                          Single s = new Sinle();
  24.                                   }
  25.                       }
  26.                       return s;
  27.              }
  28. }
复制代码


作者: 陈云阳    时间: 2014-7-20 18:28
  1.    if(s==null)//这一行是用来对象创建好之后，不用再执行判断锁的作用，因为判断锁的操作比较麻烦，至少比if语句麻烦
  2.                       {-A -B //假设俩个线程都正好到了这里
  3.                                 Synchronized(Single.class)
  4.                                  {
  5. //if(s==null)//如果这一行去掉，A先进来 创建完对象出去了，B再进来又创建对象，这不是就创建两个对象了，所以这一行不能省
  6.                                          Single s = new Sinle();
  7.                                   }
  8.                       }
  9.                       return s
复制代码

作者: 爨庚轩    时间: 2014-7-20 18:30
  1.                   if(s==null)
  2.                       {                   //1,2两个线程都走了到这里，1线程进去了，2线程等待1线程释放锁
  3.                                 Synchronized(Single.class)
  4.                                  {
  5.                                          //1线程释放锁，2线程进来了，如果不判断s==null，就会再创建一个对象
  6.                                          //如果！=null。就不创建
  7.                                          if(s==null)
  8.                                          Single s = new Sinle();
  9.                                   }
  10.                       }
复制代码
作者: 何飞    时间: 2014-7-20 19:05
本帖最后由 何飞 于 2014-7-20 19:06 编辑
  1. （2）懒汉式:延迟加载方式
  2. class Single
  3. {
  4.             //private static Single s = new Single();
  5.             private static Single s = null;//此处不实例化
  6.             private Single(){}
  7.             public static Single getInstance()
  8.             {
  9.                       if(s==null)//这里判断为空的话，就会去检测锁，每次只能进去一个。
  10.                       {
  11.                                 Synchronized(Single.class)
  12.                                  {
  13.                                            //这里肯定要判断啊，如果线程a执行完此处的代码块，在a执行的过程中线程b已经经过第一次判断，
  14.                                            //到了Synchronized代码块之前，那么等b拿到锁就会进来这里，如果不判断s是否为空，就会第二次实例化了
  15.                                           //这样就不是单例了~~
  16.                                          if(s==null)//这里有必要判断为空吗？能进来锁，就代表他是来创建对象的，何必再判断
  17.                                          Single s = new Sinle();
  18.                                   }
  19.                       }
  20.                       return s;
  21.              }
  22. }
复制代码


作者: hejinzhong    时间: 2014-7-20 19:13
是这么回事。
作者: 黄宝宝    时间: 2014-7-20 19:15
楼上正解！
作者: F@C    时间: 2014-7-20 22:24
进来学习



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