黑马程序员技术交流社区

标题: 求教，为什么老师说饿汉效率很低 [打印本页]
作者: 刘俊强    时间: 2014-4-17 18:40
标题: 求教，为什么老师说饿汉效率很低
  1. 例：（饿汉式）
  2. 1.        class Student{
  3. 2.                private static Student s=new Student();//创建本类对象
  4. 3.                private Student(){}                          //将构造函数私有化，保证对象的唯一性
  5. 4.                public static Student getStudent(){        //定义一个方法，可获得该对象
  6. return s;
  7. 5.                }
  8. 6.        }
  9. 例：（赖汉式）
  10. 7.        class Student{
  11. 8.                private static Student s=null;
  12. 9.                private Student(){}                          //将构造函数私有化，保证对象的唯一性
  13. 10.                public static Student getStudent(){        //定义一个方法，可获得该对象
  14.                       if(s==null)
  15.                       s=new Student();                //该方法被调用时，建立唯一对象
  16.                       return s;
  17. 11.                }
  18. 12.        }
复制代码
作者: ☆枫の云    时间: 2014-4-17 21:38
懒汉式是，只有用到这个用例的时候，再将他实例化，不会浪费，所以效率要高一些。
饿汉式则是程序只要开始，就将他实例化，到用到他的时候就省去了再实例的时间，所以速度和反应快。这是这俩的区别
不过差距不会那么明显。
但是大项目，在效率上体现的就有点明显了。
作者: 向日葵的曙光    时间: 2014-4-18 07:31
饿汉式只要程序运行就会New一个对象，不会判断该对象是否存在，而是直接生产一个对象。
懒汉式是根据需要来创建对象，程序运行后先判断对象是否存在，如果不存在才New一个对象，保证了安全性，避免了内存空间的浪费
另外，懒汉式需要解决同步问题，通过双重判断和同步代码块解决。
通过双重判断使其效率大大提高，减少判断次数
  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.                         if(s==null)
  9.                         //-->A 首先A进来
  10.                         //-->B B进来 两个都进来就New了多个对象
  11.                         //为了保证内存唯一性，不允许一个类存在多个对象
  12.                         s=new Single();
  13.                 }
  14.                 }       
  15.         return s;
  16.         }
  17.        
  18. }
复制代码
作者: 刘俊强    时间: 2014-4-18 08:07
麻烦帮我写一下赖汉式，双重判断要解决同步问题的代码，这个同步问题怎么产生的？
作者: 郭珍    时间: 2014-4-19 23:37
懒汉和饿汉虽然都是单例设计模式，饿汉是事先实例化，创建对象时才调用它，占用一定的内存资源，但是懒汉是预先判断是否存在实例化的对象，如果有拿来用，没有就临时创建对象，降低内存占用率，优化内存。
作者: 微笑=.一瞬间    时间: 2014-4-20 13:00
如果对某个业务类Service 采用了单例模式(饿汉式),那么其他类通过getInstance()获得的实例去访问该service 的方法,是否存在线程安全问题?代码如下
public class UrlService {


      private static UrlService instance = new UrlService();

private UrlService() {
}

public static UrlService getInstance() {
return instance;
}

public void addUrl(HttpServletRequest request) {
                Stack<String> urlStack = (Stack<String>) request.getSession().getAttribute("stack");

urlStack.push(url);
                request.getSession().setAttribute("stack", urlStack);
}


public String getUrl(HttpServletRequest request) {
Stack<String> urlStack = (Stack<String>) request.getSession().getAttribute("url");
String url = urlStack.pop();
request.getSession().setAttribute("stack", urlStack);
return url;
}

}
  多个线程访问addUrl和getUrl时是否是线程安全的?



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